[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [stem/master] stem.descriptor.networkstatus_descriptor => stem.descriptor.networkstatus



commit 4e29ae8dfc69cb68a25c9cf159e56db4e943565b
Author: Ravi Chandra Padmala <neenaoffline@xxxxxxxxx>
Date:   Tue Aug 7 12:09:25 2012 +0530

    stem.descriptor.networkstatus_descriptor => stem.descriptor.networkstatus
---
 run_tests.py                                      |    4 +-
 stem/descriptor/__init__.py                       |    2 +-
 stem/descriptor/networkstatus.py                  |  614 +++++++++++++++++++++
 stem/descriptor/networkstatus_descriptor.py       |  614 ---------------------
 test/integ/descriptor/networkstatus.py            |  228 ++++++++
 test/integ/descriptor/networkstatus_descriptor.py |  228 --------
 6 files changed, 845 insertions(+), 845 deletions(-)

diff --git a/run_tests.py b/run_tests.py
index 10aa24c..8d115f1 100755
--- a/run_tests.py
+++ b/run_tests.py
@@ -46,7 +46,7 @@ import test.integ.socket.control_socket
 import test.integ.descriptor.reader
 import test.integ.descriptor.server_descriptor
 import test.integ.descriptor.extrainfo_descriptor
-import test.integ.descriptor.networkstatus_descriptor
+import test.integ.descriptor.networkstatus
 import test.integ.response.protocolinfo
 import test.integ.util.conf
 import test.integ.util.proc
@@ -135,7 +135,7 @@ INTEG_TESTS = (
   test.integ.descriptor.reader.TestDescriptorReader,
   test.integ.descriptor.server_descriptor.TestServerDescriptor,
   test.integ.descriptor.extrainfo_descriptor.TestExtraInfoDescriptor,
-  test.integ.descriptor.networkstatus_descriptor.TestNetworkStatusDocument,
+  test.integ.descriptor.networkstatus.TestNetworkStatusDocument,
   test.integ.version.TestVersion,
   test.integ.response.protocolinfo.TestProtocolInfo,
   test.integ.process.TestProcess,
diff --git a/stem/descriptor/__init__.py b/stem/descriptor/__init__.py
index 5afe214..903a877 100644
--- a/stem/descriptor/__init__.py
+++ b/stem/descriptor/__init__.py
@@ -17,7 +17,7 @@ __all__ = [
   "reader",
   "extrainfo_descriptor",
   "server_descriptor",
-  "networkstatus_descriptor",
+  "networkstatus",
   "parse_file",
   "Descriptor",
 ]
diff --git a/stem/descriptor/networkstatus.py b/stem/descriptor/networkstatus.py
new file mode 100644
index 0000000..8daf6f7
--- /dev/null
+++ b/stem/descriptor/networkstatus.py
@@ -0,0 +1,614 @@
+"""
+Parsing for Tor network status documents. Currently supports parsing v3 network
+status documents (both votes and consensus').
+
+The network status documents also contain a list of router descriptors,
+directory authorities, signatures etc.
+
+The votes and consensus' can be obtained from any of the following sources...
+
+* the 'cached-consensus' file in tor's data directory
+* tor metrics, at https://metrics.torproject.org/data.html
+* directory authorities and mirrors via their DirPort
+
+**Module Overview:**
+
+::
+
+  parse_file - parses a network status file and provides a NetworkStatusDocument
+  NetworkStatusDocument - Tor v3 network status document
+    +- MicrodescriptorConsensus - Tor microdescriptor consensus document
+  RouterDescriptor - Router descriptor; contains information about a Tor relay
+    +- RouterMicrodescriptor - Router microdescriptor; contains information that doesn't change often
+  DirectorySignature
+  DirectoryAuthority
+"""
+
+import re
+import base64
+import hashlib
+import datetime
+
+import stem.prereq
+import stem.descriptor
+import stem.descriptor.extrainfo_descriptor
+import stem.version
+import stem.exit_policy
+import stem.util.log as log
+import stem.util.connection
+import stem.util.tor_tools
+
+_bandwidth_weights_regex = re.compile(" ".join(["W%s=\d+" % weight for weight in ["bd",
+  "be", "bg", "bm", "db", "eb", "ed", "ee", "eg", "em", "gb", "gd", "gg", "gm", "mb", "md", "me", "mg", "mm"]]))
+
+def parse_file(document_file, validate = True):
+  """
+  Iterates over the router descriptors in a network status document.
+  
+  :param file document_file: file with network status document content
+  :param bool validate: checks the validity of the document's contents if True, skips these checks otherwise
+  
+  :returns: iterator for  :class:`stem.descriptor.networkstatus_descriptor.RouterDescriptor` instances in the file
+  
+  :raises:
+    * ValueError if the contents is malformed and validate is True
+    * IOError if the file can't be read
+  """
+  
+  document = NetworkStatusDocument(document_file.read(), validate)
+  return document.router_descriptors
+
+def _strptime(string, validate = True, optional = False):
+  try:
+    return datetime.datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
+  except ValueError, exc:
+    if validate or not optional: raise exc
+
+class NetworkStatusDocument(stem.descriptor.Descriptor):
+  """
+  A v3 network status document.
+  
+  This could be a v3 consensus or vote document.
+  
+  :var bool validated: **\*** whether the document is validated
+  :var str network_status_version: **\*** a document format version. For v3 documents this is "3"
+  :var str vote_status: **\*** status of the vote (is either "vote" or "consensus")
+  :var list consensus_methods: A list of supported consensus generation methods (integers)
+  :var datetime published: time when the document was published
+  :var int consensus_method: consensus method used to generate a consensus
+  :var datetime valid_after: **\*** time when the consensus becomes valid
+  :var datetime fresh_until: **\*** time until when the consensus is considered to be fresh
+  :var datetime valid_until: **\*** time until when the consensus is valid
+  :var int vote_delay: **\*** number of seconds allowed for collecting votes from all authorities
+  :var int dist_delay: number of seconds allowed for collecting signatures from all authorities
+  :var list client_versions: list of recommended Tor client versions
+  :var list server_versions: list of recommended Tor server versions
+  :var list known_flags: **\*** list of known router flags
+  :var list params: dict of parameter(str) => value(int) mappings
+  :var list router_descriptors: **\*** list of RouterDescriptor objects defined in the document
+  :var list directory_authorities: **\*** list of DirectoryAuthority objects that have generated this document
+  :var dict bandwidth_weights: dict of weight(str) => value(int) mappings
+  :var list directory_signatures: **\*** list of signatures this document has
+  
+  **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
+  """
+  
+  def __init__(self, raw_content, validate = True):
+    """
+    Parse a v3 network status document and provide a new NetworkStatusDocument object.
+    
+    :param str raw_content: raw network status document data
+    :param bool validate: True if the document is to be validated, False otherwise
+    
+    :raises: ValueError if the document is invalid
+    """
+    
+    super(NetworkStatusDocument, self).__init__(raw_content)
+    
+    self.router_descriptors = []
+    self.directory_authorities = []
+    self.directory_signatures = []
+    self.validated = validate
+    
+    self.network_status_version = None
+    self.vote_status = None
+    self.consensus_methods = []
+    self.published = None
+    self.consensus_method = None
+    self.valid_after = None
+    self.fresh_until = None
+    self.valid_until = None
+    self.vote_delay = None
+    self.dist_delay = None
+    self.client_versions = []
+    self.server_versions = []
+    self.known_flags = []
+    self.params = {}
+    self.bandwidth_weights = {}
+    
+    self._parse(raw_content)
+  
+  def _generate_router(self, raw_content, vote, validate):
+    return RouterDescriptor(raw_content, vote, validate)
+  
+  def _validate_network_status_version(self):
+    return self.network_status_version == "3"
+  
+  def get_unrecognized_lines(self):
+    """
+    Returns any unrecognized trailing lines.
+    
+    :returns: a list of unrecognized trailing lines
+    """
+    
+    return self._unrecognized_lines
+  
+  def _parse(self, raw_content):
+    # preamble
+    validate = self.validated
+    doc_parser = stem.descriptor.DescriptorParser(raw_content, validate)
+    
+    read_keyword_line = lambda keyword, optional = False: setattr(self, keyword.replace("-", "_"), doc_parser.read_keyword_line(keyword, optional))
+    
+    map(read_keyword_line, ["network-status-version", "vote-status"])
+    if validate and not self._validate_network_status_version():
+      raise ValueError("Invalid network-status-version: %s" % self.network_status_version)
+    
+    if self.vote_status == "vote": vote = True
+    elif self.vote_status == "consensus": vote = False
+    elif validate: raise ValueError("Unrecognized document type specified in vote-status")
+    
+    if vote:
+      read_keyword_line("consensus-methods", True)
+      self.consensus_methods = [int(method) for method in self.consensus_methods.split(" ")]
+      self.published = _strptime(doc_parser.read_keyword_line("published", True), validate, True)
+    else:
+      self.consensus_method = int(doc_parser.read_keyword_line("consensus-method", True))
+    
+    map(read_keyword_line, ["valid-after", "fresh-until", "valid-until"])
+    self.valid_after = _strptime(self.valid_after, validate)
+    self.fresh_until = _strptime(self.fresh_until, validate)
+    self.valid_until = _strptime(self.valid_until, validate)
+    voting_delay = doc_parser.read_keyword_line("voting-delay")
+    self.vote_delay, self.dist_delay = [int(delay) for delay in voting_delay.split(" ")]
+    
+    client_versions = doc_parser.read_keyword_line("client-versions", True)
+    if client_versions:
+      self.client_versions = [stem.version.Version(version_string) for version_string in client_versions.split(",")]
+    server_versions = doc_parser.read_keyword_line("server-versions", True)
+    if server_versions:
+      self.server_versions = [stem.version.Version(version_string) for version_string in server_versions.split(",")]
+    self.known_flags = doc_parser.read_keyword_line("known-flags").split(" ")
+    read_keyword_line("params", True)
+    if self.params:
+      self.params = dict([(param.split("=")[0], int(param.split("=")[1])) for param in self.params.split(" ")])
+    
+    # authority section
+    while doc_parser.line.startswith("dir-source "):
+      dirauth_data = doc_parser.read_until(["dir-source", "r"])
+      self.directory_authorities.append(DirectoryAuthority(dirauth_data, vote, validate))
+    
+    def _router_desc_generator(raw_content, vote, validate):
+      parser = stem.descriptor.DescriptorParser(raw_content, validate)
+      while parser.line != None:
+        descriptor = parser.read_until("r")
+        yield self._generate_router(descriptor, vote, validate)
+    
+    # router descriptors
+    if doc_parser.peek_keyword() == "r":
+      router_descriptors_data = doc_parser.read_until(["bandwidth-weights", "directory-footer", "directory-signature"])
+      self.router_descriptors = _router_desc_generator(router_descriptors_data, vote, validate)
+    elif validate:
+      raise ValueError("No router descriptors found")
+    
+    # footer section
+    if self.consensus_method > 9 or vote and filter(lambda x: x >= 9, self.consensus_methods):
+      if doc_parser.line == "directory-footer":
+        doc_parser.read_line()
+      elif validate:
+        raise ValueError("Network status document missing directory-footer")
+    
+    if not vote:
+      read_keyword_line("bandwidth-weights", True)
+      if _bandwidth_weights_regex.match(self.bandwidth_weights):
+        self.bandwidth_weights = dict([(weight.split("=")[0], int(weight.split("=")[1])) for weight in self.bandwidth_weights.split(" ")])
+      elif validate:
+        raise ValueError("Invalid bandwidth-weights line")
+    
+    while doc_parser.line.startswith("directory-signature "):
+      signature_data = doc_parser.read_until(["directory-signature"])
+      self.directory_signatures.append(DirectorySignature(signature_data))
+    
+    self._unrecognized_lines = doc_parser.remaining()
+    if validate and self._unrecognized_lines: raise ValueError("Unrecognized trailing data")
+
+class DirectoryAuthority(stem.descriptor.Descriptor):
+  """
+  Contains directory authority information obtained from v3 network status
+  documents.
+  
+  :var str nickname: directory authority's nickname
+  :var str identity: uppercase hex fingerprint of the authority's identity key
+  :var str address: hostname
+  :var str ip: current IP address
+  :var int dirport: current directory port
+  :var int orport: current orport
+  :var str contact: directory authority's contact information
+  :var str legacy_dir_key: fingerprint of and obsolete identity key
+  :var :class:`stem.descriptor.networkstatus_descriptor.KeyCertificate` key_certificate: directory authority's current key certificate
+  :var str vote_digest: digest of the authority that contributed to the consensus
+  """
+  
+  def __init__(self, raw_content, vote = True, validate = True):
+    """
+    Parse a directory authority entry in a v3 network status document and
+    provide a DirectoryAuthority object.
+    
+    :param str raw_content: raw directory authority entry information
+    :param bool validate: True if the document is to be validated, False otherwise
+    
+    :raises: ValueError if the raw data is invalid
+    """
+    
+    super(DirectoryAuthority, self).__init__(raw_content)
+    self.nickname, self.identity, self.address, self.ip = None, None, None, None
+    self.dirport, self.orport, self.legacy_dir_key = None, None, None
+    self.key_certificate, self.contact, self.vote_digest = None, None, None
+    parser = stem.descriptor.DescriptorParser(raw_content, validate)
+    
+    dir_source = parser.read_keyword_line("dir-source")
+    self.nickname, self.identity, self.address, self.ip, self.dirport, self.orport = dir_source.split(" ")
+    self.dirport = int(self.dirport)
+    self.orport = int(self.orport)
+    
+    self.contact = parser.read_keyword_line("contact")
+    if vote:
+      self.legacy_dir_key = parser.read_keyword_line("legacy-dir-key", True)
+      self.key_certificate = KeyCertificate("\n".join(parser.remaining()), validate)
+    else:
+      self.vote_digest = parser.read_keyword_line("vote-digest", True)
+    rmng = parser.remaining()
+    if rmng and validate:
+      raise ValueError("Unrecognized trailing data in directory authority information")
+
+class KeyCertificate(stem.descriptor.Descriptor):
+  """
+  Directory key certificate.
+  
+  :var str key_certificate_version: **\*** version of the key certificate (Should be "3")
+  :var str ip: IP address on which the directory authority is listening
+  :var int port: port on which the directory authority is listening
+  :var str fingerprint: **\*** hex encoded fingerprint of the authority's identity key
+  :var str identity_key: **\*** long term authority identity key
+  :var datetime published: **\*** time (in GMT) when this document & the key were last generated
+  :var str expires: **\*** time (in GMT) after which this key becomes invalid
+  :var str signing_key: **\*** directory server's public signing key
+  :var str crosscert: signature made using certificate's signing key
+  :var str certification: **\*** signature of this key certificate signed with the identity key
+  
+  **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
+  """
+  
+  def __init__(self, raw_content, validate = True):
+    """
+    Parse a key certificate entry and provide a KeyCertificate object.
+    
+    :param str raw_content: raw key certificate information
+    :param bool validate: True if the document is to be validated, False otherwise
+    
+    :raises: ValueError if the raw data is invalid
+    """
+    
+    super(KeyCertificate, self).__init__(raw_content)
+    self.key_certificate_version, self.ip, self.port = None, None, None
+    self.fingerprint, self.identity_key, self.published = None, None, None
+    self.expires, self.signing_key, self.crosscert = None, None, None
+    self.certification = None
+    parser = stem.descriptor.DescriptorParser(raw_content, validate)
+    peek_check_kw = lambda keyword: keyword == parser.peek_keyword()
+    seen_keywords = set()
+    
+    self.key_certificate_version = parser.read_keyword_line("dir-key-certificate-version")
+    if validate and self.key_certificate_version != "3": raise ValueError("Unrecognized dir-key-certificate-version")
+    
+    def _read_keyword_line(keyword):
+      if validate and keyword in seen_keywords:
+        raise ValueError("Invalid key certificate: '%s' appears twice" % keyword)
+      seen_keywords.add(keyword)
+      return parser.read_keyword_line(keyword)
+    
+    while parser.line:
+      if peek_check_kw("dir-address"):
+        line = _read_keyword_line("dir-address")
+        try:
+          self.ip, self.port = line.rsplit(":", 1)
+          self.port = int(self.port)
+        except Exception:
+          if validate: raise ValueError("Invalid dir-address line: %s" % line)
+      
+      elif peek_check_kw("fingerprint"):
+        self.fingerprint = _read_keyword_line("fingerprint")
+      
+      elif peek_check_kw("dir-identity-key"):
+        _read_keyword_line("dir-identity-key")
+        self.identity_key = parser.read_block("RSA PUBLIC KEY")
+      
+      elif peek_check_kw("dir-key-published"):
+        self.published = _strptime(_read_keyword_line("dir-key-published"))
+      
+      elif peek_check_kw("dir-key-expires"):
+        self.expires = _strptime(_read_keyword_line("dir-key-expires"))
+      
+      elif peek_check_kw("dir-signing-key"):
+        _read_keyword_line("dir-signing-key")
+        self.signing_key = parser.read_block("RSA PUBLIC KEY")
+      
+      elif peek_check_kw("dir-key-crosscert"):
+        _read_keyword_line("dir-key-crosscert")
+        self.crosscert = parser.read_block("ID SIGNATURE")
+      
+      elif peek_check_kw("dir-key-certification"):
+        _read_keyword_line("dir-key-certification")
+        self.certification = parser.read_block("SIGNATURE")
+        break
+      
+      elif validate:
+        raise ValueError("Key certificate contains unrecognized lines: %s" % parser.line)
+      
+      else:
+        # ignore unrecognized lines if we aren't validating
+        self._unrecognized_lines.append(parser.read_line())
+    
+    self._unrecognized_lines = parser.remaining()
+    if self._unrecognized_lines and validate:
+      raise ValueError("Unrecognized trailing data in key certificate")
+  
+  def get_unrecognized_lines(self):
+    """
+    Returns any unrecognized lines.
+    
+    :returns: a list of unrecognized lines
+    """
+    
+    return self._unrecognized_lines
+
+class DirectorySignature(stem.descriptor.Descriptor):
+  """
+  Contains directory signature information described in a v3 network status
+  document.
+  
+  :var str identity: signature identity
+  :var str key_digest: signature key digest
+  :var str method: method used to generate the signature
+  :var str signature: the signature data
+  """
+  
+  def __init__(self, raw_content, validate = True):
+    """
+    Parse a directory signature entry in a v3 network status document and
+    provide a DirectorySignature object.
+    
+    :param str raw_content: raw directory signature entry information
+    :param bool validate: True if the document is to be validated, False otherwise
+    
+    :raises: ValueError if the raw data is invalid
+    """
+    
+    super(DirectorySignature, self).__init__(raw_content)
+    self.identity, self.key_digest, self.method, self.signature = None, None, None, None
+    parser = stem.descriptor.DescriptorParser(raw_content, validate)
+    
+    signature_line = parser.read_keyword_line("directory-signature").split(" ")
+    
+    if len(signature_line) == 2:
+      self.identity, self.key_digest = signature_line
+    if len(signature_line) == 3: # for microdescriptor consensuses
+      self.method, self.identity, self.key_digest = signature_line
+    
+    self.signature = parser.read_block("SIGNATURE")
+    self._unrecognized_lines = parser.remaining()
+    if self._unrecognized_lines and validate:
+      raise ValueError("Unrecognized trailing data in directory signature")
+
+class RouterDescriptor(stem.descriptor.Descriptor):
+  """
+  Router descriptor object. Parses and stores router information in a router
+  entry read from a v3 network status document.
+  
+  :var str nickname: **\*** router's nickname
+  :var str identity: **\*** router's identity
+  :var str digest: **\*** router's digest
+  :var datetime publication: **\*** router's publication
+  :var str ip: **\*** router's IP address
+  :var int orport: **\*** router's ORPort
+  :var int dirport: **\*** router's DirPort
+  
+  :var bool is_valid: **\*** router is valid
+  :var bool is_guard: **\*** router is suitable for use as an entry guard
+  :var bool is_named: **\*** router is named
+  :var bool is_unnamed: **\*** router is unnamed
+  :var bool is_running: **\*** router is running and currently usable
+  :var bool is_stable: **\*** router is stable, i.e., it's suitable for for long-lived circuits
+  :var bool is_exit: **\*** router is an exit router
+  :var bool is_fast: **\*** router is Fast, i.e., it's usable for high-bandwidth circuits
+  :var bool is_authority: **\*** router is a directory authority
+  :var bool supports_v2dir: **\*** router supports v2dir
+  :var bool supports_v3dir: **\*** router supports v3dir
+  :var bool is_hsdir: **\*** router is a hidden status
+  :var bool is_badexit: **\*** router is marked a bad exit
+  :var bool is_baddirectory: **\*** router is a bad directory
+  
+  :var :class:`stem.version.Version`,str version: Version of the Tor protocol this router is running
+  
+  :var int bandwidth: router's claimed bandwidth
+  :var int measured_bandwidth: router's measured bandwidth
+  
+  :var :class:`stem.exit_policy.MicrodescriptorExitPolicy` exitpolicy: router's exitpolicy
+  
+  :var str microdescriptor_hashes: a list of two-tuples with a list of consensus methods(int) that may produce the digest and a dict with algorithm(str) => digest(str) mappings. algorithm is the hashing algorithm (usually "sha256") that is used to produce digest (the base64 encoding of the hash of the router's microdescriptor with trailing =s omitted).
+  
+  **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
+  """
+  
+  def __init__(self, raw_contents, vote = True, validate = True):
+    """
+    Parse a router descriptor in a v3 network status document and provide a new
+    RouterDescriptor object.
+    
+    :param str raw_content: router descriptor content to be parsed
+    :param bool validate: whether the router descriptor should be validated
+    """
+    
+    super(RouterDescriptor, self).__init__(raw_contents)
+    
+    self.nickname = None
+    self.identity = None
+    self.digest = None
+    self.publication = None
+    self.ip = None
+    self.orport = None
+    self.dirport = None
+    
+    self.is_valid = False
+    self.is_guard = False
+    self.is_named = False
+    self.is_unnamed = False
+    self.is_running = False
+    self.is_stable = False
+    self.is_exit = False
+    self.is_fast = False
+    self.is_authority = False
+    self.supports_v2dir = False
+    self.supports_v3dir = False
+    self.is_hsdir = False
+    self.is_badexit = False
+    self.is_baddirectory = False
+    
+    self.version = None
+    
+    self.bandwidth = None
+    self.measured_bandwidth = None
+    
+    self.exit_policy = None
+    
+    self.microdescriptor_hashes = []
+    
+    self._parse(raw_contents, vote, validate)
+  
+  def _parse(self, raw_content, vote, validate):
+    """
+    :param dict raw_content: iptor contents to be applied
+    :param bool validate: checks the validity of descriptor content if True
+    
+    :raises: ValueError if an error occures in validation
+    """
+    
+    parser = stem.descriptor.DescriptorParser(raw_content, validate)
+    seen_keywords = set()
+    peek_check_kw = lambda keyword: keyword == parser.peek_keyword()
+    
+    r = parser.read_keyword_line("r")
+    # r mauer BD7xbfsCFku3+tgybEZsg8Yjhvw itcuKQ6PuPLJ7m/Oi928WjO2j8g 2012-06-22 13:19:32 80.101.105.103 9001 0
+    # "r" SP nickname SP identity SP digest SP publication SP IP SP ORPort SP DirPort NL
+    seen_keywords.add("r")
+    if r:
+      values = r.split(" ")
+      self.nickname, self.identity, self.digest = values[0], values[1], values[2]
+      self.publication = _strptime(" ".join((values[3], values[4])), validate)
+      self.ip, self.orport, self.dirport = values[5], int(values[6]), int(values[7])
+      if self.dirport == 0: self.dirport = None
+    elif validate: raise ValueError("Invalid router descriptor: empty 'r' line" )
+    
+    while parser.line:
+      if peek_check_kw("s"):
+        if "s" in seen_keywords: raise ValueError("Invalid router descriptor: 's' line appears twice")
+        line = parser.read_keyword_line("s")
+        if not line: continue
+        seen_keywords.add("s")
+        # s Named Running Stable Valid
+        #A series of space-separated status flags, in *lexical order*
+        flags = line.split(" ")
+        flag_map = {
+          "Valid": "is_valid",
+          "Guard": "is_guard",
+          "Named": "is_named",
+          "Unnamed": "is_unnamed",
+          "Running": "is_running",
+          "Stable": "is_stable",
+          "Exit": "is_exit",
+          "Fast": "is_fast",
+          "Authority": "is_authority",
+          "V2Dir": "supports_v2dir",
+          "V3Dir": "supports_v3dir",
+          "HSDir": "is_hsdir",
+          "BadExit": "is_badexit",
+          "BadDirectory": "is_baddirectory",
+        }
+        map(lambda flag: setattr(self, flag_map[flag], True), flags)
+        
+        if self.is_unnamed: self.is_named = False
+        elif self.is_named: self.is_unnamed = False
+      
+      elif peek_check_kw("v"):
+        if "v" in seen_keywords: raise ValueError("Invalid router descriptor: 'v' line appears twice")
+        line = parser.read_keyword_line("v", True)
+        seen_keywords.add("v")
+        # v Tor 0.2.2.35
+        if line:
+          if line.startswith("Tor "):
+            self.version = stem.version.Version(line[4:])
+          else:
+            self.version = line
+        elif validate: raise ValueError("Invalid router descriptor: empty 'v' line" )
+      
+      elif peek_check_kw("w"):
+        if "w" in seen_keywords: raise ValueError("Invalid router descriptor: 'w' line appears twice")
+        w = parser.read_keyword_line("w", True)
+        # "w" SP "Bandwidth=" INT [SP "Measured=" INT] NL
+        seen_keywords.add("w")
+        if w:
+          values = w.split(" ")
+          if len(values) <= 2 and len(values) > 0:
+            key, value = values[0].split("=")
+            if key == "Bandwidth": self.bandwidth = int(value)
+            elif validate: raise ValueError("Router descriptor contains invalid 'w' line: expected Bandwidth, read " + key)
+            
+            if len(values) == 2:
+              key, value = values[1].split("=")
+              if key == "Measured": self.measured_bandwidth = int(value)
+              elif validate: raise ValueError("Router descriptor contains invalid 'w' line: expected Measured, read " + key)
+          elif validate: raise ValueError("Router descriptor contains invalid 'w' line")
+        elif validate: raise ValueError("Router descriptor contains empty 'w' line")
+      
+      elif peek_check_kw("p"):
+        if "p" in seen_keywords: raise ValueError("Invalid router descriptor: 'p' line appears twice")
+        p = parser.read_keyword_line("p", True)
+        seen_keywords.add("p")
+        # "p" SP ("accept" / "reject") SP PortList NL
+        if p:
+          self.exit_policy = stem.exit_policy.MicrodescriptorExitPolicy(p)
+          #self.exit_policy = p
+      
+      elif vote and peek_check_kw("m"):
+        # microdescriptor hashes
+        m = parser.read_keyword_line("m", True)
+        methods, digests = m.split(" ", 1)
+        method_list = methods.split(",")
+        digest_dict = [digest.split("=", 1) for digest in digests.split(" ")]
+        self.microdescriptor_hashes.append((method_list, digest_dict))
+      
+      elif validate:
+        raise ValueError("Router descriptor contains unrecognized trailing lines: %s" % parser.line)
+      
+      else:
+        self._unrecognized_lines.append(parser.read_line()) # ignore unrecognized lines if we aren't validating
+  
+  def get_unrecognized_lines(self):
+    """
+    Returns any unrecognized lines.
+    
+    :returns: a list of unrecognized lines
+    """
+    
+    return self._unrecognized_lines
+
diff --git a/stem/descriptor/networkstatus_descriptor.py b/stem/descriptor/networkstatus_descriptor.py
deleted file mode 100644
index 8daf6f7..0000000
--- a/stem/descriptor/networkstatus_descriptor.py
+++ /dev/null
@@ -1,614 +0,0 @@
-"""
-Parsing for Tor network status documents. Currently supports parsing v3 network
-status documents (both votes and consensus').
-
-The network status documents also contain a list of router descriptors,
-directory authorities, signatures etc.
-
-The votes and consensus' can be obtained from any of the following sources...
-
-* the 'cached-consensus' file in tor's data directory
-* tor metrics, at https://metrics.torproject.org/data.html
-* directory authorities and mirrors via their DirPort
-
-**Module Overview:**
-
-::
-
-  parse_file - parses a network status file and provides a NetworkStatusDocument
-  NetworkStatusDocument - Tor v3 network status document
-    +- MicrodescriptorConsensus - Tor microdescriptor consensus document
-  RouterDescriptor - Router descriptor; contains information about a Tor relay
-    +- RouterMicrodescriptor - Router microdescriptor; contains information that doesn't change often
-  DirectorySignature
-  DirectoryAuthority
-"""
-
-import re
-import base64
-import hashlib
-import datetime
-
-import stem.prereq
-import stem.descriptor
-import stem.descriptor.extrainfo_descriptor
-import stem.version
-import stem.exit_policy
-import stem.util.log as log
-import stem.util.connection
-import stem.util.tor_tools
-
-_bandwidth_weights_regex = re.compile(" ".join(["W%s=\d+" % weight for weight in ["bd",
-  "be", "bg", "bm", "db", "eb", "ed", "ee", "eg", "em", "gb", "gd", "gg", "gm", "mb", "md", "me", "mg", "mm"]]))
-
-def parse_file(document_file, validate = True):
-  """
-  Iterates over the router descriptors in a network status document.
-  
-  :param file document_file: file with network status document content
-  :param bool validate: checks the validity of the document's contents if True, skips these checks otherwise
-  
-  :returns: iterator for  :class:`stem.descriptor.networkstatus_descriptor.RouterDescriptor` instances in the file
-  
-  :raises:
-    * ValueError if the contents is malformed and validate is True
-    * IOError if the file can't be read
-  """
-  
-  document = NetworkStatusDocument(document_file.read(), validate)
-  return document.router_descriptors
-
-def _strptime(string, validate = True, optional = False):
-  try:
-    return datetime.datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
-  except ValueError, exc:
-    if validate or not optional: raise exc
-
-class NetworkStatusDocument(stem.descriptor.Descriptor):
-  """
-  A v3 network status document.
-  
-  This could be a v3 consensus or vote document.
-  
-  :var bool validated: **\*** whether the document is validated
-  :var str network_status_version: **\*** a document format version. For v3 documents this is "3"
-  :var str vote_status: **\*** status of the vote (is either "vote" or "consensus")
-  :var list consensus_methods: A list of supported consensus generation methods (integers)
-  :var datetime published: time when the document was published
-  :var int consensus_method: consensus method used to generate a consensus
-  :var datetime valid_after: **\*** time when the consensus becomes valid
-  :var datetime fresh_until: **\*** time until when the consensus is considered to be fresh
-  :var datetime valid_until: **\*** time until when the consensus is valid
-  :var int vote_delay: **\*** number of seconds allowed for collecting votes from all authorities
-  :var int dist_delay: number of seconds allowed for collecting signatures from all authorities
-  :var list client_versions: list of recommended Tor client versions
-  :var list server_versions: list of recommended Tor server versions
-  :var list known_flags: **\*** list of known router flags
-  :var list params: dict of parameter(str) => value(int) mappings
-  :var list router_descriptors: **\*** list of RouterDescriptor objects defined in the document
-  :var list directory_authorities: **\*** list of DirectoryAuthority objects that have generated this document
-  :var dict bandwidth_weights: dict of weight(str) => value(int) mappings
-  :var list directory_signatures: **\*** list of signatures this document has
-  
-  **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
-  """
-  
-  def __init__(self, raw_content, validate = True):
-    """
-    Parse a v3 network status document and provide a new NetworkStatusDocument object.
-    
-    :param str raw_content: raw network status document data
-    :param bool validate: True if the document is to be validated, False otherwise
-    
-    :raises: ValueError if the document is invalid
-    """
-    
-    super(NetworkStatusDocument, self).__init__(raw_content)
-    
-    self.router_descriptors = []
-    self.directory_authorities = []
-    self.directory_signatures = []
-    self.validated = validate
-    
-    self.network_status_version = None
-    self.vote_status = None
-    self.consensus_methods = []
-    self.published = None
-    self.consensus_method = None
-    self.valid_after = None
-    self.fresh_until = None
-    self.valid_until = None
-    self.vote_delay = None
-    self.dist_delay = None
-    self.client_versions = []
-    self.server_versions = []
-    self.known_flags = []
-    self.params = {}
-    self.bandwidth_weights = {}
-    
-    self._parse(raw_content)
-  
-  def _generate_router(self, raw_content, vote, validate):
-    return RouterDescriptor(raw_content, vote, validate)
-  
-  def _validate_network_status_version(self):
-    return self.network_status_version == "3"
-  
-  def get_unrecognized_lines(self):
-    """
-    Returns any unrecognized trailing lines.
-    
-    :returns: a list of unrecognized trailing lines
-    """
-    
-    return self._unrecognized_lines
-  
-  def _parse(self, raw_content):
-    # preamble
-    validate = self.validated
-    doc_parser = stem.descriptor.DescriptorParser(raw_content, validate)
-    
-    read_keyword_line = lambda keyword, optional = False: setattr(self, keyword.replace("-", "_"), doc_parser.read_keyword_line(keyword, optional))
-    
-    map(read_keyword_line, ["network-status-version", "vote-status"])
-    if validate and not self._validate_network_status_version():
-      raise ValueError("Invalid network-status-version: %s" % self.network_status_version)
-    
-    if self.vote_status == "vote": vote = True
-    elif self.vote_status == "consensus": vote = False
-    elif validate: raise ValueError("Unrecognized document type specified in vote-status")
-    
-    if vote:
-      read_keyword_line("consensus-methods", True)
-      self.consensus_methods = [int(method) for method in self.consensus_methods.split(" ")]
-      self.published = _strptime(doc_parser.read_keyword_line("published", True), validate, True)
-    else:
-      self.consensus_method = int(doc_parser.read_keyword_line("consensus-method", True))
-    
-    map(read_keyword_line, ["valid-after", "fresh-until", "valid-until"])
-    self.valid_after = _strptime(self.valid_after, validate)
-    self.fresh_until = _strptime(self.fresh_until, validate)
-    self.valid_until = _strptime(self.valid_until, validate)
-    voting_delay = doc_parser.read_keyword_line("voting-delay")
-    self.vote_delay, self.dist_delay = [int(delay) for delay in voting_delay.split(" ")]
-    
-    client_versions = doc_parser.read_keyword_line("client-versions", True)
-    if client_versions:
-      self.client_versions = [stem.version.Version(version_string) for version_string in client_versions.split(",")]
-    server_versions = doc_parser.read_keyword_line("server-versions", True)
-    if server_versions:
-      self.server_versions = [stem.version.Version(version_string) for version_string in server_versions.split(",")]
-    self.known_flags = doc_parser.read_keyword_line("known-flags").split(" ")
-    read_keyword_line("params", True)
-    if self.params:
-      self.params = dict([(param.split("=")[0], int(param.split("=")[1])) for param in self.params.split(" ")])
-    
-    # authority section
-    while doc_parser.line.startswith("dir-source "):
-      dirauth_data = doc_parser.read_until(["dir-source", "r"])
-      self.directory_authorities.append(DirectoryAuthority(dirauth_data, vote, validate))
-    
-    def _router_desc_generator(raw_content, vote, validate):
-      parser = stem.descriptor.DescriptorParser(raw_content, validate)
-      while parser.line != None:
-        descriptor = parser.read_until("r")
-        yield self._generate_router(descriptor, vote, validate)
-    
-    # router descriptors
-    if doc_parser.peek_keyword() == "r":
-      router_descriptors_data = doc_parser.read_until(["bandwidth-weights", "directory-footer", "directory-signature"])
-      self.router_descriptors = _router_desc_generator(router_descriptors_data, vote, validate)
-    elif validate:
-      raise ValueError("No router descriptors found")
-    
-    # footer section
-    if self.consensus_method > 9 or vote and filter(lambda x: x >= 9, self.consensus_methods):
-      if doc_parser.line == "directory-footer":
-        doc_parser.read_line()
-      elif validate:
-        raise ValueError("Network status document missing directory-footer")
-    
-    if not vote:
-      read_keyword_line("bandwidth-weights", True)
-      if _bandwidth_weights_regex.match(self.bandwidth_weights):
-        self.bandwidth_weights = dict([(weight.split("=")[0], int(weight.split("=")[1])) for weight in self.bandwidth_weights.split(" ")])
-      elif validate:
-        raise ValueError("Invalid bandwidth-weights line")
-    
-    while doc_parser.line.startswith("directory-signature "):
-      signature_data = doc_parser.read_until(["directory-signature"])
-      self.directory_signatures.append(DirectorySignature(signature_data))
-    
-    self._unrecognized_lines = doc_parser.remaining()
-    if validate and self._unrecognized_lines: raise ValueError("Unrecognized trailing data")
-
-class DirectoryAuthority(stem.descriptor.Descriptor):
-  """
-  Contains directory authority information obtained from v3 network status
-  documents.
-  
-  :var str nickname: directory authority's nickname
-  :var str identity: uppercase hex fingerprint of the authority's identity key
-  :var str address: hostname
-  :var str ip: current IP address
-  :var int dirport: current directory port
-  :var int orport: current orport
-  :var str contact: directory authority's contact information
-  :var str legacy_dir_key: fingerprint of and obsolete identity key
-  :var :class:`stem.descriptor.networkstatus_descriptor.KeyCertificate` key_certificate: directory authority's current key certificate
-  :var str vote_digest: digest of the authority that contributed to the consensus
-  """
-  
-  def __init__(self, raw_content, vote = True, validate = True):
-    """
-    Parse a directory authority entry in a v3 network status document and
-    provide a DirectoryAuthority object.
-    
-    :param str raw_content: raw directory authority entry information
-    :param bool validate: True if the document is to be validated, False otherwise
-    
-    :raises: ValueError if the raw data is invalid
-    """
-    
-    super(DirectoryAuthority, self).__init__(raw_content)
-    self.nickname, self.identity, self.address, self.ip = None, None, None, None
-    self.dirport, self.orport, self.legacy_dir_key = None, None, None
-    self.key_certificate, self.contact, self.vote_digest = None, None, None
-    parser = stem.descriptor.DescriptorParser(raw_content, validate)
-    
-    dir_source = parser.read_keyword_line("dir-source")
-    self.nickname, self.identity, self.address, self.ip, self.dirport, self.orport = dir_source.split(" ")
-    self.dirport = int(self.dirport)
-    self.orport = int(self.orport)
-    
-    self.contact = parser.read_keyword_line("contact")
-    if vote:
-      self.legacy_dir_key = parser.read_keyword_line("legacy-dir-key", True)
-      self.key_certificate = KeyCertificate("\n".join(parser.remaining()), validate)
-    else:
-      self.vote_digest = parser.read_keyword_line("vote-digest", True)
-    rmng = parser.remaining()
-    if rmng and validate:
-      raise ValueError("Unrecognized trailing data in directory authority information")
-
-class KeyCertificate(stem.descriptor.Descriptor):
-  """
-  Directory key certificate.
-  
-  :var str key_certificate_version: **\*** version of the key certificate (Should be "3")
-  :var str ip: IP address on which the directory authority is listening
-  :var int port: port on which the directory authority is listening
-  :var str fingerprint: **\*** hex encoded fingerprint of the authority's identity key
-  :var str identity_key: **\*** long term authority identity key
-  :var datetime published: **\*** time (in GMT) when this document & the key were last generated
-  :var str expires: **\*** time (in GMT) after which this key becomes invalid
-  :var str signing_key: **\*** directory server's public signing key
-  :var str crosscert: signature made using certificate's signing key
-  :var str certification: **\*** signature of this key certificate signed with the identity key
-  
-  **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
-  """
-  
-  def __init__(self, raw_content, validate = True):
-    """
-    Parse a key certificate entry and provide a KeyCertificate object.
-    
-    :param str raw_content: raw key certificate information
-    :param bool validate: True if the document is to be validated, False otherwise
-    
-    :raises: ValueError if the raw data is invalid
-    """
-    
-    super(KeyCertificate, self).__init__(raw_content)
-    self.key_certificate_version, self.ip, self.port = None, None, None
-    self.fingerprint, self.identity_key, self.published = None, None, None
-    self.expires, self.signing_key, self.crosscert = None, None, None
-    self.certification = None
-    parser = stem.descriptor.DescriptorParser(raw_content, validate)
-    peek_check_kw = lambda keyword: keyword == parser.peek_keyword()
-    seen_keywords = set()
-    
-    self.key_certificate_version = parser.read_keyword_line("dir-key-certificate-version")
-    if validate and self.key_certificate_version != "3": raise ValueError("Unrecognized dir-key-certificate-version")
-    
-    def _read_keyword_line(keyword):
-      if validate and keyword in seen_keywords:
-        raise ValueError("Invalid key certificate: '%s' appears twice" % keyword)
-      seen_keywords.add(keyword)
-      return parser.read_keyword_line(keyword)
-    
-    while parser.line:
-      if peek_check_kw("dir-address"):
-        line = _read_keyword_line("dir-address")
-        try:
-          self.ip, self.port = line.rsplit(":", 1)
-          self.port = int(self.port)
-        except Exception:
-          if validate: raise ValueError("Invalid dir-address line: %s" % line)
-      
-      elif peek_check_kw("fingerprint"):
-        self.fingerprint = _read_keyword_line("fingerprint")
-      
-      elif peek_check_kw("dir-identity-key"):
-        _read_keyword_line("dir-identity-key")
-        self.identity_key = parser.read_block("RSA PUBLIC KEY")
-      
-      elif peek_check_kw("dir-key-published"):
-        self.published = _strptime(_read_keyword_line("dir-key-published"))
-      
-      elif peek_check_kw("dir-key-expires"):
-        self.expires = _strptime(_read_keyword_line("dir-key-expires"))
-      
-      elif peek_check_kw("dir-signing-key"):
-        _read_keyword_line("dir-signing-key")
-        self.signing_key = parser.read_block("RSA PUBLIC KEY")
-      
-      elif peek_check_kw("dir-key-crosscert"):
-        _read_keyword_line("dir-key-crosscert")
-        self.crosscert = parser.read_block("ID SIGNATURE")
-      
-      elif peek_check_kw("dir-key-certification"):
-        _read_keyword_line("dir-key-certification")
-        self.certification = parser.read_block("SIGNATURE")
-        break
-      
-      elif validate:
-        raise ValueError("Key certificate contains unrecognized lines: %s" % parser.line)
-      
-      else:
-        # ignore unrecognized lines if we aren't validating
-        self._unrecognized_lines.append(parser.read_line())
-    
-    self._unrecognized_lines = parser.remaining()
-    if self._unrecognized_lines and validate:
-      raise ValueError("Unrecognized trailing data in key certificate")
-  
-  def get_unrecognized_lines(self):
-    """
-    Returns any unrecognized lines.
-    
-    :returns: a list of unrecognized lines
-    """
-    
-    return self._unrecognized_lines
-
-class DirectorySignature(stem.descriptor.Descriptor):
-  """
-  Contains directory signature information described in a v3 network status
-  document.
-  
-  :var str identity: signature identity
-  :var str key_digest: signature key digest
-  :var str method: method used to generate the signature
-  :var str signature: the signature data
-  """
-  
-  def __init__(self, raw_content, validate = True):
-    """
-    Parse a directory signature entry in a v3 network status document and
-    provide a DirectorySignature object.
-    
-    :param str raw_content: raw directory signature entry information
-    :param bool validate: True if the document is to be validated, False otherwise
-    
-    :raises: ValueError if the raw data is invalid
-    """
-    
-    super(DirectorySignature, self).__init__(raw_content)
-    self.identity, self.key_digest, self.method, self.signature = None, None, None, None
-    parser = stem.descriptor.DescriptorParser(raw_content, validate)
-    
-    signature_line = parser.read_keyword_line("directory-signature").split(" ")
-    
-    if len(signature_line) == 2:
-      self.identity, self.key_digest = signature_line
-    if len(signature_line) == 3: # for microdescriptor consensuses
-      self.method, self.identity, self.key_digest = signature_line
-    
-    self.signature = parser.read_block("SIGNATURE")
-    self._unrecognized_lines = parser.remaining()
-    if self._unrecognized_lines and validate:
-      raise ValueError("Unrecognized trailing data in directory signature")
-
-class RouterDescriptor(stem.descriptor.Descriptor):
-  """
-  Router descriptor object. Parses and stores router information in a router
-  entry read from a v3 network status document.
-  
-  :var str nickname: **\*** router's nickname
-  :var str identity: **\*** router's identity
-  :var str digest: **\*** router's digest
-  :var datetime publication: **\*** router's publication
-  :var str ip: **\*** router's IP address
-  :var int orport: **\*** router's ORPort
-  :var int dirport: **\*** router's DirPort
-  
-  :var bool is_valid: **\*** router is valid
-  :var bool is_guard: **\*** router is suitable for use as an entry guard
-  :var bool is_named: **\*** router is named
-  :var bool is_unnamed: **\*** router is unnamed
-  :var bool is_running: **\*** router is running and currently usable
-  :var bool is_stable: **\*** router is stable, i.e., it's suitable for for long-lived circuits
-  :var bool is_exit: **\*** router is an exit router
-  :var bool is_fast: **\*** router is Fast, i.e., it's usable for high-bandwidth circuits
-  :var bool is_authority: **\*** router is a directory authority
-  :var bool supports_v2dir: **\*** router supports v2dir
-  :var bool supports_v3dir: **\*** router supports v3dir
-  :var bool is_hsdir: **\*** router is a hidden status
-  :var bool is_badexit: **\*** router is marked a bad exit
-  :var bool is_baddirectory: **\*** router is a bad directory
-  
-  :var :class:`stem.version.Version`,str version: Version of the Tor protocol this router is running
-  
-  :var int bandwidth: router's claimed bandwidth
-  :var int measured_bandwidth: router's measured bandwidth
-  
-  :var :class:`stem.exit_policy.MicrodescriptorExitPolicy` exitpolicy: router's exitpolicy
-  
-  :var str microdescriptor_hashes: a list of two-tuples with a list of consensus methods(int) that may produce the digest and a dict with algorithm(str) => digest(str) mappings. algorithm is the hashing algorithm (usually "sha256") that is used to produce digest (the base64 encoding of the hash of the router's microdescriptor with trailing =s omitted).
-  
-  **\*** attribute is either required when we're parsed with validation or has a default value, others are left as None if undefined
-  """
-  
-  def __init__(self, raw_contents, vote = True, validate = True):
-    """
-    Parse a router descriptor in a v3 network status document and provide a new
-    RouterDescriptor object.
-    
-    :param str raw_content: router descriptor content to be parsed
-    :param bool validate: whether the router descriptor should be validated
-    """
-    
-    super(RouterDescriptor, self).__init__(raw_contents)
-    
-    self.nickname = None
-    self.identity = None
-    self.digest = None
-    self.publication = None
-    self.ip = None
-    self.orport = None
-    self.dirport = None
-    
-    self.is_valid = False
-    self.is_guard = False
-    self.is_named = False
-    self.is_unnamed = False
-    self.is_running = False
-    self.is_stable = False
-    self.is_exit = False
-    self.is_fast = False
-    self.is_authority = False
-    self.supports_v2dir = False
-    self.supports_v3dir = False
-    self.is_hsdir = False
-    self.is_badexit = False
-    self.is_baddirectory = False
-    
-    self.version = None
-    
-    self.bandwidth = None
-    self.measured_bandwidth = None
-    
-    self.exit_policy = None
-    
-    self.microdescriptor_hashes = []
-    
-    self._parse(raw_contents, vote, validate)
-  
-  def _parse(self, raw_content, vote, validate):
-    """
-    :param dict raw_content: iptor contents to be applied
-    :param bool validate: checks the validity of descriptor content if True
-    
-    :raises: ValueError if an error occures in validation
-    """
-    
-    parser = stem.descriptor.DescriptorParser(raw_content, validate)
-    seen_keywords = set()
-    peek_check_kw = lambda keyword: keyword == parser.peek_keyword()
-    
-    r = parser.read_keyword_line("r")
-    # r mauer BD7xbfsCFku3+tgybEZsg8Yjhvw itcuKQ6PuPLJ7m/Oi928WjO2j8g 2012-06-22 13:19:32 80.101.105.103 9001 0
-    # "r" SP nickname SP identity SP digest SP publication SP IP SP ORPort SP DirPort NL
-    seen_keywords.add("r")
-    if r:
-      values = r.split(" ")
-      self.nickname, self.identity, self.digest = values[0], values[1], values[2]
-      self.publication = _strptime(" ".join((values[3], values[4])), validate)
-      self.ip, self.orport, self.dirport = values[5], int(values[6]), int(values[7])
-      if self.dirport == 0: self.dirport = None
-    elif validate: raise ValueError("Invalid router descriptor: empty 'r' line" )
-    
-    while parser.line:
-      if peek_check_kw("s"):
-        if "s" in seen_keywords: raise ValueError("Invalid router descriptor: 's' line appears twice")
-        line = parser.read_keyword_line("s")
-        if not line: continue
-        seen_keywords.add("s")
-        # s Named Running Stable Valid
-        #A series of space-separated status flags, in *lexical order*
-        flags = line.split(" ")
-        flag_map = {
-          "Valid": "is_valid",
-          "Guard": "is_guard",
-          "Named": "is_named",
-          "Unnamed": "is_unnamed",
-          "Running": "is_running",
-          "Stable": "is_stable",
-          "Exit": "is_exit",
-          "Fast": "is_fast",
-          "Authority": "is_authority",
-          "V2Dir": "supports_v2dir",
-          "V3Dir": "supports_v3dir",
-          "HSDir": "is_hsdir",
-          "BadExit": "is_badexit",
-          "BadDirectory": "is_baddirectory",
-        }
-        map(lambda flag: setattr(self, flag_map[flag], True), flags)
-        
-        if self.is_unnamed: self.is_named = False
-        elif self.is_named: self.is_unnamed = False
-      
-      elif peek_check_kw("v"):
-        if "v" in seen_keywords: raise ValueError("Invalid router descriptor: 'v' line appears twice")
-        line = parser.read_keyword_line("v", True)
-        seen_keywords.add("v")
-        # v Tor 0.2.2.35
-        if line:
-          if line.startswith("Tor "):
-            self.version = stem.version.Version(line[4:])
-          else:
-            self.version = line
-        elif validate: raise ValueError("Invalid router descriptor: empty 'v' line" )
-      
-      elif peek_check_kw("w"):
-        if "w" in seen_keywords: raise ValueError("Invalid router descriptor: 'w' line appears twice")
-        w = parser.read_keyword_line("w", True)
-        # "w" SP "Bandwidth=" INT [SP "Measured=" INT] NL
-        seen_keywords.add("w")
-        if w:
-          values = w.split(" ")
-          if len(values) <= 2 and len(values) > 0:
-            key, value = values[0].split("=")
-            if key == "Bandwidth": self.bandwidth = int(value)
-            elif validate: raise ValueError("Router descriptor contains invalid 'w' line: expected Bandwidth, read " + key)
-            
-            if len(values) == 2:
-              key, value = values[1].split("=")
-              if key == "Measured": self.measured_bandwidth = int(value)
-              elif validate: raise ValueError("Router descriptor contains invalid 'w' line: expected Measured, read " + key)
-          elif validate: raise ValueError("Router descriptor contains invalid 'w' line")
-        elif validate: raise ValueError("Router descriptor contains empty 'w' line")
-      
-      elif peek_check_kw("p"):
-        if "p" in seen_keywords: raise ValueError("Invalid router descriptor: 'p' line appears twice")
-        p = parser.read_keyword_line("p", True)
-        seen_keywords.add("p")
-        # "p" SP ("accept" / "reject") SP PortList NL
-        if p:
-          self.exit_policy = stem.exit_policy.MicrodescriptorExitPolicy(p)
-          #self.exit_policy = p
-      
-      elif vote and peek_check_kw("m"):
-        # microdescriptor hashes
-        m = parser.read_keyword_line("m", True)
-        methods, digests = m.split(" ", 1)
-        method_list = methods.split(",")
-        digest_dict = [digest.split("=", 1) for digest in digests.split(" ")]
-        self.microdescriptor_hashes.append((method_list, digest_dict))
-      
-      elif validate:
-        raise ValueError("Router descriptor contains unrecognized trailing lines: %s" % parser.line)
-      
-      else:
-        self._unrecognized_lines.append(parser.read_line()) # ignore unrecognized lines if we aren't validating
-  
-  def get_unrecognized_lines(self):
-    """
-    Returns any unrecognized lines.
-    
-    :returns: a list of unrecognized lines
-    """
-    
-    return self._unrecognized_lines
-
diff --git a/test/integ/descriptor/networkstatus.py b/test/integ/descriptor/networkstatus.py
new file mode 100644
index 0000000..e65d960
--- /dev/null
+++ b/test/integ/descriptor/networkstatus.py
@@ -0,0 +1,228 @@
+"""
+Integration tests for stem.descriptor.server_descriptor.
+"""
+
+from __future__ import with_statement
+
+import os
+import resource
+import datetime
+import unittest
+
+import stem.exit_policy
+import stem.version
+import stem.descriptor.networkstatus
+import test.integ.descriptor
+
+def _strptime(string):
+  return datetime.datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
+
+class TestNetworkStatusDocument(unittest.TestCase):
+  def test_metrics_consensus(self):
+    """
+    Checks if consensus documents from Metrics are parsed properly.
+    """
+    
+    descriptor_path = test.integ.descriptor.get_resource("metrics_consensus")
+    
+    with file(descriptor_path) as descriptor_file:
+      desc = stem.descriptor.parse_file(descriptor_path, descriptor_file)
+      
+      router = next(desc)
+      self.assertEquals("sumkledi", router.nickname)
+      self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router.identity)
+      self.assertEquals("8mCr8Sl7RF4ENU4jb0FZFA/3do8", router.digest)
+      self.assertEquals(_strptime("2012-07-12 04:01:55"), router.publication)
+      self.assertEquals("178.218.213.229", router.ip)
+      self.assertEquals(80, router.orport)
+      self.assertEquals(None, router.dirport)
+  
+  def test_cached_consensus(self):
+    """
+    Parses the cached-consensus file in our data directory.
+    """
+    
+    # lengthy test and uneffected by targets, so only run once
+    if test.runner.only_run_once(self, "test_cached_consensus"): return
+    
+    descriptor_path = test.runner.get_runner().get_test_dir("cached-consensus")
+    
+    if not os.path.exists(descriptor_path):
+      test.runner.skip(self, "(no cached-consensus)")
+    
+    if stem.util.system.is_windows():
+      # might hog memory and hang the system
+      # and we aren't checking for memory usage in windows, so, skip.
+      test.runner.skip(self, "(unavailable on windows)")
+    
+    count = 0
+    with open(descriptor_path) as descriptor_file:
+      for desc in stem.descriptor.networkstatus.parse_file(descriptor_file):
+        if resource.getrusage(resource.RUSAGE_SELF).ru_maxrss > 100000:
+          # if we're using > 100 MB we should fail
+          self.fail()
+        assert desc.nickname # check that the router has a nickname
+        count += 1
+    
+    assert count > 100 # sanity check - assuming atleast 100 relays in the Tor network
+  
+  def test_consensus(self):
+    """
+    Checks that consensus documents are properly parsed.
+    """
+    
+    descriptor_path = test.integ.descriptor.get_resource("consensus")
+    
+    descriptor_file = file(descriptor_path)
+    desc = stem.descriptor.networkstatus.NetworkStatusDocument(descriptor_file.read())
+    descriptor_file.close()
+    
+    self.assertEquals(True, desc.validated)
+    self.assertEquals("3", desc.network_status_version)
+    self.assertEquals("consensus", desc.vote_status)
+    self.assertEquals([], desc.consensus_methods)
+    self.assertEquals(None, desc.published)
+    self.assertEquals(12, desc.consensus_method)
+    self.assertEquals(_strptime("2012-07-12 10:00:00"), desc.valid_after)
+    self.assertEquals(_strptime("2012-07-12 11:00:00"), desc.fresh_until)
+    self.assertEquals(_strptime("2012-07-12 13:00:00"), desc.valid_until)
+    self.assertEquals(300, desc.vote_delay)
+    self.assertEquals(300, desc.dist_delay)
+    expected_client_versions = [stem.version.Version(version_string) for version_string in ["0.2.2.35",
+      "0.2.2.36", "0.2.2.37", "0.2.3.10-alpha", "0.2.3.11-alpha", "0.2.3.12-alpha",
+      "0.2.3.13-alpha", "0.2.3.14-alpha", "0.2.3.15-alpha", "0.2.3.16-alpha", "0.2.3.17-beta",
+      "0.2.3.18-rc", "0.2.3.19-rc"]]
+    expected_server_versions = [stem.version.Version(version_string) for version_string in ["0.2.2.35",
+      "0.2.2.36", "0.2.2.37", "0.2.3.10-alpha", "0.2.3.11-alpha", "0.2.3.12-alpha",
+      "0.2.3.13-alpha", "0.2.3.14-alpha", "0.2.3.15-alpha", "0.2.3.16-alpha", "0.2.3.17-beta",
+      "0.2.3.18-rc", "0.2.3.19-rc"]]
+    self.assertEquals(expected_client_versions, desc.client_versions)
+    self.assertEquals(expected_server_versions, desc.server_versions)
+    known_flags = ["Authority", "BadExit", "Exit", "Fast", "Guard", "HSDir", "Named", "Running", "Stable", "Unnamed", "V2Dir", "Valid"]
+    self.assertEquals(known_flags, desc.known_flags)
+    expected_params = {"CircuitPriorityHalflifeMsec": 30000, "bwauthpid": 1}
+    self.assertEquals(expected_params, desc.params)
+    router1 = next(desc.router_descriptors)
+    self.assertEquals("sumkledi", router1.nickname)
+    self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router1.identity)
+    self.assertEquals("8mCr8Sl7RF4ENU4jb0FZFA/3do8", router1.digest)
+    self.assertEquals(_strptime("2012-07-12 04:01:55"), router1.publication)
+    self.assertEquals("178.218.213.229", router1.ip)
+    self.assertEquals(80, router1.orport)
+    self.assertEquals(None, router1.dirport)
+    
+    self.assertEquals(8, len(desc.directory_authorities))
+    self.assertEquals("tor26", desc.directory_authorities[0].nickname)
+    self.assertEquals("14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4", desc.directory_authorities[0].identity)
+    self.assertEquals("86.59.21.38", desc.directory_authorities[0].address)
+    self.assertEquals("86.59.21.38", desc.directory_authorities[0].ip)
+    self.assertEquals(80, desc.directory_authorities[0].dirport)
+    self.assertEquals(443, desc.directory_authorities[0].orport)
+    self.assertEquals("Peter Palfrader", desc.directory_authorities[0].contact)
+    self.assertEquals(None, desc.directory_authorities[0].legacy_dir_key)
+    self.assertEquals(None, desc.directory_authorities[0].key_certificate)
+    self.assertEquals("0B6D1E9A300B895AA2D0B427F92917B6995C3C1C", desc.directory_authorities[0].vote_digest)
+    expected_bandwidth_weights = {
+        "Wbd": 3335, "Wbe": 0, "Wbg": 3536, "Wbm": 10000, "Wdb": 10000, "Web": 10000,
+        "Wed": 3329, "Wee": 10000, "Weg": 3329, "Wem": 10000, "Wgb": 10000, "Wgd": 3335,
+        "Wgg": 6464, "Wgm": 6464, "Wmb": 10000, "Wmd": 3335, "Wme": 0, "Wmg": 3536, "Wmm": 10000
+        }
+    self.assertEquals(expected_bandwidth_weights, desc.bandwidth_weights)
+    
+    expected_signature = """HFXB4497LzESysYJ/4jJY83E5vLjhv+igIxD9LU6lf6ftkGeF+lNmIAIEKaMts8H
+mfWcW0b+jsrXcJoCxV5IrwCDF3u1aC3diwZY6yiG186pwWbOwE41188XI2DeYPwE
+I/TJmV928na7RLZe2mGHCAW3VQOvV+QkCfj05VZ8CsY="""
+    self.assertEquals(8, len(desc.directory_signatures))
+    self.assertEquals("14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4", desc.directory_signatures[0].identity)
+    self.assertEquals("BF112F1C6D5543CFD0A32215ACABD4197B5279AD", desc.directory_signatures[0].key_digest)
+    self.assertEquals(expected_signature, desc.directory_signatures[0].signature)
+  
+  def test_vote(self):
+    """
+    Checks that vote documents are properly parsed.
+    """
+    
+    descriptor_path = test.integ.descriptor.get_resource("vote")
+    
+    descriptor_file = file(descriptor_path)
+    desc = stem.descriptor.networkstatus.NetworkStatusDocument(descriptor_file.read())
+    descriptor_file.close()
+    
+    self.assertEquals(True, desc.validated)
+    self.assertEquals("3", desc.network_status_version)
+    self.assertEquals("vote", desc.vote_status)
+    self.assertEquals(range(1, 13), desc.consensus_methods)
+    self.assertEquals(_strptime("2012-07-11 23:50:01"), desc.published)
+    self.assertEquals(None, desc.consensus_method)
+    self.assertEquals(_strptime("2012-07-12 00:00:00"), desc.valid_after)
+    self.assertEquals(_strptime("2012-07-12 01:00:00"), desc.fresh_until)
+    self.assertEquals(_strptime("2012-07-12 03:00:00"), desc.valid_until)
+    self.assertEquals(300, desc.vote_delay)
+    self.assertEquals(300, desc.dist_delay)
+    self.assertEquals([], desc.client_versions)
+    self.assertEquals([], desc.server_versions)
+    known_flags = ["Authority", "BadExit", "Exit", "Fast", "Guard", "HSDir", "Running", "Stable", "V2Dir", "Valid"]
+    self.assertEquals(known_flags, desc.known_flags)
+    expected_params = {"CircuitPriorityHalflifeMsec": 30000, "bwauthpid": 1}
+    self.assertEquals(expected_params, desc.params)
+    router1 = next(desc.router_descriptors)
+    self.assertEquals("sumkledi", router1.nickname)
+    self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router1.identity)
+    self.assertEquals("B5n4BiALAF8B5AqafxohyYiuj7E", router1.digest)
+    self.assertEquals(_strptime("2012-07-11 04:22:53"), router1.publication)
+    self.assertEquals("178.218.213.229", router1.ip)
+    self.assertEquals(80, router1.orport)
+    self.assertEquals(None, router1.dirport)
+    
+    self.assertEquals(1, len(desc.directory_authorities))
+    self.assertEquals("turtles", desc.directory_authorities[0].nickname)
+    self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_authorities[0].identity)
+    self.assertEquals("76.73.17.194", desc.directory_authorities[0].address)
+    self.assertEquals("76.73.17.194", desc.directory_authorities[0].ip)
+    self.assertEquals(9030, desc.directory_authorities[0].dirport)
+    self.assertEquals(9090, desc.directory_authorities[0].orport)
+    self.assertEquals("Mike Perry <email>", desc.directory_authorities[0].contact)
+    self.assertEquals(None, desc.directory_authorities[0].legacy_dir_key)
+    
+    expected_identity_key = """MIIBigKCAYEA6uSmsoxj2MiJ3qyZq0qYXlRoG8o82SNqg+22m+t1c7MlQOZWPJYn
+XeMcBCt8xrTeIt2ZI+Q/Kt2QJSeD9WZRevTKk/kn5Tg2+xXPogalUU47y5tUohGz
++Q8+CxtRSXpDxBHL2P8rLHvGrI69wbNHGoQkce/7gJy9vw5Ie2qzbyXk1NG6V8Fb
+pr6A885vHo6TbhUnolz2Wqt/kN+UorjLkN2H3fV+iGcQFv42SyHYGDLa0WwL3PJJ
+r/veu36S3VaHBrfhutfioi+d3d4Ya0bKwiWi5Lm2CHuuRTgMpHLU9vlci8Hunuxq
+HsULe2oMsr4VEic7sW5SPC5Obpx6hStHdNv1GxoSEm3/vIuPM8pINpU5ZYAyH9yO
+Ef22ZHeiVMMKmpV9TtFyiFqvlI6GpQn3mNbsQqF1y3XCA3Q4vlRAkpgJVUSvTxFP
+2bNDobOyVCpCM/rwxU1+RCNY5MFJ/+oktUY+0ydvTen3gFdZdgNqCYjKPLfBNm9m
+RGL7jZunMUNvAgMBAAE="""
+    expected_signing_key = """MIGJAoGBAJ5itcJRYNEM3Qf1OVWLRkwjqf84oXPc2ZusaJ5zOe7TVvBMra9GNyc0
+NM9y6zVkHCAePAjr4KbW/8P1olA6FUE2LV9bozaU1jFf6K8B2OELKs5FUEW+n+ic
+GM0x6MhngyXonWOcKt5Gj+mAu5lrno9tpNbPkz2Utr/Pi0nsDhWlAgMBAAE="""
+    expected_key_crosscert = """RHYImGTwg36wmEdAn7qaRg2sAfql7ZCtPIL/O3lU5OIdXXp0tNn/K00Bamqohjk+
+Tz4FKsKXGDlbGv67PQcZPOK6NF0GRkNh4pk89prrDO4XwtEn7rkHHdBH6/qQ7IRG
+GdDZHtZ1a69oFZvPWD3hUaB50xeIe7GoKdKIfdNNJ+8="""
+    expected_key_certification = """fasWOGyUZ3iMCYpDfJ+0JcMiTH25sXPWzvlHorEOyOMbaMqRYpZU4GHzt1jLgdl6
+AAoR6KdamsLg5VE8xzst48a4UFuzHFlklZ5O8om2rcvDd5DhSnWWYZnYJecqB+bo
+dNisPmaIVSAWb29U8BpNRj4GMC9KAgGYUj8aE/KtutAeEekFfFEHTfWZ2fFp4j3m
+9rY8FWraqyiF+Emq1T8pAAgMQ+79R3oZxq0TXS42Z4Anhms735ccauKhI3pDKjbl
+tD5vAzIHOyjAOXj7a6jY/GrnaBNuJ4qe/4Hf9UmzK/jKKwG95BPJtPTT4LoFwEB0
+KG2OUeQUNoCck4nDpsZwFqPlrWCHcHfTV2iDYFV1HQWDTtZz/qf+GtB8NXsq+I1w
+brADmvReM2BD6p/13h0QURCI5hq7ZYlIKcKrBa0jn1d9cduULl7vgKsRCJDls/ID
+emBZ6pUxMpBmV0v+PrA3v9w4DlE7GHAq61FF/zju2kpqj6MInbEvI/E+e438sWsL"""
+    self.assertEquals("3", desc.directory_authorities[0].key_certificate.key_certificate_version)
+    self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_authorities[0].key_certificate.fingerprint)
+    self.assertEquals(_strptime("2011-11-28 21:51:04"), desc.directory_authorities[0].key_certificate.published)
+    self.assertEquals(_strptime("2012-11-28 21:51:04"), desc.directory_authorities[0].key_certificate.expires)
+    self.assertEquals(expected_identity_key, desc.directory_authorities[0].key_certificate.identity_key)
+    self.assertEquals(expected_signing_key, desc.directory_authorities[0].key_certificate.signing_key)
+    self.assertEquals(expected_key_crosscert, desc.directory_authorities[0].key_certificate.crosscert)
+    self.assertEquals(expected_key_certification, desc.directory_authorities[0].key_certificate.certification)
+    self.assertEquals(None, desc.directory_authorities[0].vote_digest)
+    self.assertEquals({}, desc.bandwidth_weights)
+    
+    expected_signature = """fskXN84wB3mXfo+yKGSt0AcDaaPuU3NwMR3ROxWgLN0KjAaVi2eV9PkPCsQkcgw3
+JZ/1HL9sHyZfo6bwaC6YSM9PNiiY6L7rnGpS7UkHiFI+M96VCMorvjm5YPs3FioJ
+DnN5aFtYKiTc19qIC7Nmo+afPdDEf0MlJvEOP5EWl3w="""
+    self.assertEquals(1, len(desc.directory_signatures))
+    self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_signatures[0].identity)
+    self.assertEquals("D5C30C15BB3F1DA27669C2D88439939E8F418FCF", desc.directory_signatures[0].key_digest)
+    self.assertEquals(expected_signature, desc.directory_signatures[0].signature)
+
diff --git a/test/integ/descriptor/networkstatus_descriptor.py b/test/integ/descriptor/networkstatus_descriptor.py
deleted file mode 100644
index 46019ea..0000000
--- a/test/integ/descriptor/networkstatus_descriptor.py
+++ /dev/null
@@ -1,228 +0,0 @@
-"""
-Integration tests for stem.descriptor.server_descriptor.
-"""
-
-from __future__ import with_statement
-
-import os
-import resource
-import datetime
-import unittest
-
-import stem.exit_policy
-import stem.version
-import stem.descriptor.networkstatus_descriptor
-import test.integ.descriptor
-
-def _strptime(string):
-  return datetime.datetime.strptime(string, "%Y-%m-%d %H:%M:%S")
-
-class TestNetworkStatusDocument(unittest.TestCase):
-  def test_metrics_consensus(self):
-    """
-    Checks if consensus documents from Metrics are parsed properly.
-    """
-    
-    descriptor_path = test.integ.descriptor.get_resource("metrics_consensus")
-    
-    with file(descriptor_path) as descriptor_file:
-      desc = stem.descriptor.parse_file(descriptor_path, descriptor_file)
-      
-      router = next(desc)
-      self.assertEquals("sumkledi", router.nickname)
-      self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router.identity)
-      self.assertEquals("8mCr8Sl7RF4ENU4jb0FZFA/3do8", router.digest)
-      self.assertEquals(_strptime("2012-07-12 04:01:55"), router.publication)
-      self.assertEquals("178.218.213.229", router.ip)
-      self.assertEquals(80, router.orport)
-      self.assertEquals(None, router.dirport)
-  
-  def test_cached_consensus(self):
-    """
-    Parses the cached-consensus file in our data directory.
-    """
-    
-    # lengthy test and uneffected by targets, so only run once
-    if test.runner.only_run_once(self, "test_cached_consensus"): return
-    
-    descriptor_path = test.runner.get_runner().get_test_dir("cached-consensus")
-    
-    if not os.path.exists(descriptor_path):
-      test.runner.skip(self, "(no cached-consensus)")
-    
-    if stem.util.system.is_windows():
-      # might hog memory and hang the system
-      # and we aren't checking for memory usage in windows, so, skip.
-      test.runner.skip(self, "(unavailable on windows)")
-    
-    count = 0
-    with open(descriptor_path) as descriptor_file:
-      for desc in stem.descriptor.networkstatus_descriptor.parse_file(descriptor_file):
-        if resource.getrusage(resource.RUSAGE_SELF).ru_maxrss > 100000:
-          # if we're using > 100 MB we should fail
-          self.fail()
-        assert desc.nickname # check that the router has a nickname
-        count += 1
-    
-    assert count > 100 # sanity check - assuming atleast 100 relays in the Tor network
-  
-  def test_consensus(self):
-    """
-    Checks that consensus documents are properly parsed.
-    """
-    
-    descriptor_path = test.integ.descriptor.get_resource("consensus")
-    
-    descriptor_file = file(descriptor_path)
-    desc = stem.descriptor.networkstatus_descriptor.NetworkStatusDocument(descriptor_file.read())
-    descriptor_file.close()
-    
-    self.assertEquals(True, desc.validated)
-    self.assertEquals("3", desc.network_status_version)
-    self.assertEquals("consensus", desc.vote_status)
-    self.assertEquals([], desc.consensus_methods)
-    self.assertEquals(None, desc.published)
-    self.assertEquals(12, desc.consensus_method)
-    self.assertEquals(_strptime("2012-07-12 10:00:00"), desc.valid_after)
-    self.assertEquals(_strptime("2012-07-12 11:00:00"), desc.fresh_until)
-    self.assertEquals(_strptime("2012-07-12 13:00:00"), desc.valid_until)
-    self.assertEquals(300, desc.vote_delay)
-    self.assertEquals(300, desc.dist_delay)
-    expected_client_versions = [stem.version.Version(version_string) for version_string in ["0.2.2.35",
-      "0.2.2.36", "0.2.2.37", "0.2.3.10-alpha", "0.2.3.11-alpha", "0.2.3.12-alpha",
-      "0.2.3.13-alpha", "0.2.3.14-alpha", "0.2.3.15-alpha", "0.2.3.16-alpha", "0.2.3.17-beta",
-      "0.2.3.18-rc", "0.2.3.19-rc"]]
-    expected_server_versions = [stem.version.Version(version_string) for version_string in ["0.2.2.35",
-      "0.2.2.36", "0.2.2.37", "0.2.3.10-alpha", "0.2.3.11-alpha", "0.2.3.12-alpha",
-      "0.2.3.13-alpha", "0.2.3.14-alpha", "0.2.3.15-alpha", "0.2.3.16-alpha", "0.2.3.17-beta",
-      "0.2.3.18-rc", "0.2.3.19-rc"]]
-    self.assertEquals(expected_client_versions, desc.client_versions)
-    self.assertEquals(expected_server_versions, desc.server_versions)
-    known_flags = ["Authority", "BadExit", "Exit", "Fast", "Guard", "HSDir", "Named", "Running", "Stable", "Unnamed", "V2Dir", "Valid"]
-    self.assertEquals(known_flags, desc.known_flags)
-    expected_params = {"CircuitPriorityHalflifeMsec": 30000, "bwauthpid": 1}
-    self.assertEquals(expected_params, desc.params)
-    router1 = next(desc.router_descriptors)
-    self.assertEquals("sumkledi", router1.nickname)
-    self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router1.identity)
-    self.assertEquals("8mCr8Sl7RF4ENU4jb0FZFA/3do8", router1.digest)
-    self.assertEquals(_strptime("2012-07-12 04:01:55"), router1.publication)
-    self.assertEquals("178.218.213.229", router1.ip)
-    self.assertEquals(80, router1.orport)
-    self.assertEquals(None, router1.dirport)
-    
-    self.assertEquals(8, len(desc.directory_authorities))
-    self.assertEquals("tor26", desc.directory_authorities[0].nickname)
-    self.assertEquals("14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4", desc.directory_authorities[0].identity)
-    self.assertEquals("86.59.21.38", desc.directory_authorities[0].address)
-    self.assertEquals("86.59.21.38", desc.directory_authorities[0].ip)
-    self.assertEquals(80, desc.directory_authorities[0].dirport)
-    self.assertEquals(443, desc.directory_authorities[0].orport)
-    self.assertEquals("Peter Palfrader", desc.directory_authorities[0].contact)
-    self.assertEquals(None, desc.directory_authorities[0].legacy_dir_key)
-    self.assertEquals(None, desc.directory_authorities[0].key_certificate)
-    self.assertEquals("0B6D1E9A300B895AA2D0B427F92917B6995C3C1C", desc.directory_authorities[0].vote_digest)
-    expected_bandwidth_weights = {
-        "Wbd": 3335, "Wbe": 0, "Wbg": 3536, "Wbm": 10000, "Wdb": 10000, "Web": 10000,
-        "Wed": 3329, "Wee": 10000, "Weg": 3329, "Wem": 10000, "Wgb": 10000, "Wgd": 3335,
-        "Wgg": 6464, "Wgm": 6464, "Wmb": 10000, "Wmd": 3335, "Wme": 0, "Wmg": 3536, "Wmm": 10000
-        }
-    self.assertEquals(expected_bandwidth_weights, desc.bandwidth_weights)
-    
-    expected_signature = """HFXB4497LzESysYJ/4jJY83E5vLjhv+igIxD9LU6lf6ftkGeF+lNmIAIEKaMts8H
-mfWcW0b+jsrXcJoCxV5IrwCDF3u1aC3diwZY6yiG186pwWbOwE41188XI2DeYPwE
-I/TJmV928na7RLZe2mGHCAW3VQOvV+QkCfj05VZ8CsY="""
-    self.assertEquals(8, len(desc.directory_signatures))
-    self.assertEquals("14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4", desc.directory_signatures[0].identity)
-    self.assertEquals("BF112F1C6D5543CFD0A32215ACABD4197B5279AD", desc.directory_signatures[0].key_digest)
-    self.assertEquals(expected_signature, desc.directory_signatures[0].signature)
-  
-  def test_vote(self):
-    """
-    Checks that vote documents are properly parsed.
-    """
-    
-    descriptor_path = test.integ.descriptor.get_resource("vote")
-    
-    descriptor_file = file(descriptor_path)
-    desc = stem.descriptor.networkstatus_descriptor.NetworkStatusDocument(descriptor_file.read())
-    descriptor_file.close()
-    
-    self.assertEquals(True, desc.validated)
-    self.assertEquals("3", desc.network_status_version)
-    self.assertEquals("vote", desc.vote_status)
-    self.assertEquals(range(1, 13), desc.consensus_methods)
-    self.assertEquals(_strptime("2012-07-11 23:50:01"), desc.published)
-    self.assertEquals(None, desc.consensus_method)
-    self.assertEquals(_strptime("2012-07-12 00:00:00"), desc.valid_after)
-    self.assertEquals(_strptime("2012-07-12 01:00:00"), desc.fresh_until)
-    self.assertEquals(_strptime("2012-07-12 03:00:00"), desc.valid_until)
-    self.assertEquals(300, desc.vote_delay)
-    self.assertEquals(300, desc.dist_delay)
-    self.assertEquals([], desc.client_versions)
-    self.assertEquals([], desc.server_versions)
-    known_flags = ["Authority", "BadExit", "Exit", "Fast", "Guard", "HSDir", "Running", "Stable", "V2Dir", "Valid"]
-    self.assertEquals(known_flags, desc.known_flags)
-    expected_params = {"CircuitPriorityHalflifeMsec": 30000, "bwauthpid": 1}
-    self.assertEquals(expected_params, desc.params)
-    router1 = next(desc.router_descriptors)
-    self.assertEquals("sumkledi", router1.nickname)
-    self.assertEquals("ABPSI4nNUNC3hKPkBhyzHozozrU", router1.identity)
-    self.assertEquals("B5n4BiALAF8B5AqafxohyYiuj7E", router1.digest)
-    self.assertEquals(_strptime("2012-07-11 04:22:53"), router1.publication)
-    self.assertEquals("178.218.213.229", router1.ip)
-    self.assertEquals(80, router1.orport)
-    self.assertEquals(None, router1.dirport)
-    
-    self.assertEquals(1, len(desc.directory_authorities))
-    self.assertEquals("turtles", desc.directory_authorities[0].nickname)
-    self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_authorities[0].identity)
-    self.assertEquals("76.73.17.194", desc.directory_authorities[0].address)
-    self.assertEquals("76.73.17.194", desc.directory_authorities[0].ip)
-    self.assertEquals(9030, desc.directory_authorities[0].dirport)
-    self.assertEquals(9090, desc.directory_authorities[0].orport)
-    self.assertEquals("Mike Perry <email>", desc.directory_authorities[0].contact)
-    self.assertEquals(None, desc.directory_authorities[0].legacy_dir_key)
-    
-    expected_identity_key = """MIIBigKCAYEA6uSmsoxj2MiJ3qyZq0qYXlRoG8o82SNqg+22m+t1c7MlQOZWPJYn
-XeMcBCt8xrTeIt2ZI+Q/Kt2QJSeD9WZRevTKk/kn5Tg2+xXPogalUU47y5tUohGz
-+Q8+CxtRSXpDxBHL2P8rLHvGrI69wbNHGoQkce/7gJy9vw5Ie2qzbyXk1NG6V8Fb
-pr6A885vHo6TbhUnolz2Wqt/kN+UorjLkN2H3fV+iGcQFv42SyHYGDLa0WwL3PJJ
-r/veu36S3VaHBrfhutfioi+d3d4Ya0bKwiWi5Lm2CHuuRTgMpHLU9vlci8Hunuxq
-HsULe2oMsr4VEic7sW5SPC5Obpx6hStHdNv1GxoSEm3/vIuPM8pINpU5ZYAyH9yO
-Ef22ZHeiVMMKmpV9TtFyiFqvlI6GpQn3mNbsQqF1y3XCA3Q4vlRAkpgJVUSvTxFP
-2bNDobOyVCpCM/rwxU1+RCNY5MFJ/+oktUY+0ydvTen3gFdZdgNqCYjKPLfBNm9m
-RGL7jZunMUNvAgMBAAE="""
-    expected_signing_key = """MIGJAoGBAJ5itcJRYNEM3Qf1OVWLRkwjqf84oXPc2ZusaJ5zOe7TVvBMra9GNyc0
-NM9y6zVkHCAePAjr4KbW/8P1olA6FUE2LV9bozaU1jFf6K8B2OELKs5FUEW+n+ic
-GM0x6MhngyXonWOcKt5Gj+mAu5lrno9tpNbPkz2Utr/Pi0nsDhWlAgMBAAE="""
-    expected_key_crosscert = """RHYImGTwg36wmEdAn7qaRg2sAfql7ZCtPIL/O3lU5OIdXXp0tNn/K00Bamqohjk+
-Tz4FKsKXGDlbGv67PQcZPOK6NF0GRkNh4pk89prrDO4XwtEn7rkHHdBH6/qQ7IRG
-GdDZHtZ1a69oFZvPWD3hUaB50xeIe7GoKdKIfdNNJ+8="""
-    expected_key_certification = """fasWOGyUZ3iMCYpDfJ+0JcMiTH25sXPWzvlHorEOyOMbaMqRYpZU4GHzt1jLgdl6
-AAoR6KdamsLg5VE8xzst48a4UFuzHFlklZ5O8om2rcvDd5DhSnWWYZnYJecqB+bo
-dNisPmaIVSAWb29U8BpNRj4GMC9KAgGYUj8aE/KtutAeEekFfFEHTfWZ2fFp4j3m
-9rY8FWraqyiF+Emq1T8pAAgMQ+79R3oZxq0TXS42Z4Anhms735ccauKhI3pDKjbl
-tD5vAzIHOyjAOXj7a6jY/GrnaBNuJ4qe/4Hf9UmzK/jKKwG95BPJtPTT4LoFwEB0
-KG2OUeQUNoCck4nDpsZwFqPlrWCHcHfTV2iDYFV1HQWDTtZz/qf+GtB8NXsq+I1w
-brADmvReM2BD6p/13h0QURCI5hq7ZYlIKcKrBa0jn1d9cduULl7vgKsRCJDls/ID
-emBZ6pUxMpBmV0v+PrA3v9w4DlE7GHAq61FF/zju2kpqj6MInbEvI/E+e438sWsL"""
-    self.assertEquals("3", desc.directory_authorities[0].key_certificate.key_certificate_version)
-    self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_authorities[0].key_certificate.fingerprint)
-    self.assertEquals(_strptime("2011-11-28 21:51:04"), desc.directory_authorities[0].key_certificate.published)
-    self.assertEquals(_strptime("2012-11-28 21:51:04"), desc.directory_authorities[0].key_certificate.expires)
-    self.assertEquals(expected_identity_key, desc.directory_authorities[0].key_certificate.identity_key)
-    self.assertEquals(expected_signing_key, desc.directory_authorities[0].key_certificate.signing_key)
-    self.assertEquals(expected_key_crosscert, desc.directory_authorities[0].key_certificate.crosscert)
-    self.assertEquals(expected_key_certification, desc.directory_authorities[0].key_certificate.certification)
-    self.assertEquals(None, desc.directory_authorities[0].vote_digest)
-    self.assertEquals({}, desc.bandwidth_weights)
-    
-    expected_signature = """fskXN84wB3mXfo+yKGSt0AcDaaPuU3NwMR3ROxWgLN0KjAaVi2eV9PkPCsQkcgw3
-JZ/1HL9sHyZfo6bwaC6YSM9PNiiY6L7rnGpS7UkHiFI+M96VCMorvjm5YPs3FioJ
-DnN5aFtYKiTc19qIC7Nmo+afPdDEf0MlJvEOP5EWl3w="""
-    self.assertEquals(1, len(desc.directory_signatures))
-    self.assertEquals("27B6B5996C426270A5C95488AA5BCEB6BCC86956", desc.directory_signatures[0].identity)
-    self.assertEquals("D5C30C15BB3F1DA27669C2D88439939E8F418FCF", desc.directory_signatures[0].key_digest)
-    self.assertEquals(expected_signature, desc.directory_signatures[0].signature)
-



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits