s/rpki.rpki_rtr/rpki.rtr/g

svn path=/trunk/; revision=5819

9 files changed, 76 insertions, 73 deletions

diff --git a/rp/rpki-rtr/rpki-rtr b/rp/rpki-rtr/rpki-rtr
index b764a0b3..5ad4cf26 100755
--- a/rp/rpki-rtr/rpki-rtr
+++ b/rp/rpki-rtr/rpki-rtr
@@ -19,5 +19,5 @@
 # PERFORMANCE OF THIS SOFTWARE.
 
 if __name__ == "__main__":
-  from rpki.rpki_rtr.main import main
+  from rpki.rtr.main import main
   main()
diff --git a/rpki/rpki_rtr/__init__.py b/rpki/rtr/__init__.py
index e69de29b..e69de29b 100644
--- a/rpki/rpki_rtr/__init__.py
+++ b/rpki/rtr/__init__.py
diff --git a/rpki/rpki_rtr/channels.py b/rpki/rtr/channels.py
index d2a8972f..53295900 100644
--- a/rpki/rpki_rtr/channels.py
+++ b/rpki/rtr/channels.py
@@ -28,7 +28,7 @@ import errno
 import logging
 import asyncore
 import asynchat
-import rpki.rpki_rtr.pdus
+import rpki.rtr.pdus
 
 
 class Timestamp(int):
@@ -121,10 +121,10 @@ class ReadBuffer(object):
     """
 
     if self.version is not None and version != self.version:
-      raise rpki.rpki_rtr.pdus.CorruptData(
+      raise rpki.rtr.pdus.CorruptData(
         "Received PDU version %d, expected %d" % (version, self.version))
-    if self.version is None and version not in rpki.rpki_rtr.pdus.PDU.version_map:
-      raise rpki.rpki_rtr.pdus.UnsupportedProtocolVersion(
+    if self.version is None and version not in rpki.rtr.pdus.PDU.version_map:
+      raise rpki.rtr.pdus.UnsupportedProtocolVersion(
         "Received PDU version %d, known versions %s" % (version, ", ".PDU.version_map.iterkeys()))
     self.version = version
 
@@ -140,7 +140,7 @@ class PDUChannel(asynchat.async_chat, object):
   def __init__(self, root_pdu_class, sock = None):
     asynchat.async_chat.__init__(self, sock)            # Old-style class, can't use super()
     self.reader = ReadBuffer()
-    assert issubclass(root_pdu_class, rpki.rpki_rtr.pdus.PDU)
+    assert issubclass(root_pdu_class, rpki.rtr.pdus.PDU)
     self.root_pdu_class = root_pdu_class
 
   @property
@@ -161,7 +161,7 @@ class PDUChannel(asynchat.async_chat, object):
       while p is not None:
         self.deliver_pdu(p)
         p = self.root_pdu_class.read_pdu(self.reader)
-    except rpki.rpki_rtr.pdus.PDUException, e:
+    except rpki.rtr.pdus.PDUException, e:
       self.push_pdu(e.make_error_report(version = self.version))
       self.close_when_done()
     else:
diff --git a/rpki/rpki_rtr/client.py b/rpki/rtr/client.py
index 0ba3688f..1cf29835 100644
--- a/rpki/rpki_rtr/client.py
+++ b/rpki/rtr/client.py
@@ -29,14 +29,14 @@ import signal
 import logging
 import asyncore
 import subprocess
-import rpki.rpki_rtr.pdus
-import rpki.rpki_rtr.channels
+import rpki.rtr.pdus
+import rpki.rtr.channels
 
-from rpki.rpki_rtr.pdus import ResetQueryPDU, SerialQueryPDU
-from rpki.rpki_rtr.channels import Timestamp
+from rpki.rtr.pdus     import ResetQueryPDU, SerialQueryPDU
+from rpki.rtr.channels import Timestamp
 
 
-class PDU(rpki.rpki_rtr.pdus.PDU):
+class PDU(rpki.rtr.pdus.PDU):
   """
   Object representing a generic PDU in the rpki-router protocol.
   Real PDUs are subclasses of this class.
@@ -51,11 +51,11 @@ class PDU(rpki.rpki_rtr.pdus.PDU):
     logging.debug(self)
 
 
-clone_pdu = rpki.rpki_rtr.pdus.clone_pdu_root(PDU)
+clone_pdu = rpki.rtr.pdus.clone_pdu_root(PDU)
 
 
 @clone_pdu
-class SerialNotifyPDU(rpki.rpki_rtr.pdus.SerialNotifyPDU):
+class SerialNotifyPDU(rpki.rtr.pdus.SerialNotifyPDU):
   """
   Serial Notify PDU.
   """
@@ -78,7 +78,7 @@ class SerialNotifyPDU(rpki.rpki_rtr.pdus.SerialNotifyPDU):
 
 
 @clone_pdu
-class CacheResponsePDU(rpki.rpki_rtr.pdus.CacheResponsePDU):
+class CacheResponsePDU(rpki.rtr.pdus.CacheResponsePDU):
   """
   Cache Response PDU.
   """
@@ -94,7 +94,7 @@ class CacheResponsePDU(rpki.rpki_rtr.pdus.CacheResponsePDU):
       client.cache_reset()
 
 @clone_pdu
-class EndOfDataPDUv0(rpki.rpki_rtr.pdus.EndOfDataPDUv0):
+class EndOfDataPDUv0(rpki.rtr.pdus.EndOfDataPDUv0):
   """
   End of Data PDU, protocol version 0.
   """
@@ -108,7 +108,7 @@ class EndOfDataPDUv0(rpki.rpki_rtr.pdus.EndOfDataPDUv0):
     client.end_of_data(self.version, self.serial, self.nonce, self.refresh, self.retry, self.expire)
 
 @clone_pdu
-class EndOfDataPDUv1(rpki.rpki_rtr.pdus.EndOfDataPDUv1):
+class EndOfDataPDUv1(rpki.rtr.pdus.EndOfDataPDUv1):
   """
   End of Data PDU, protocol version 1.
   """
@@ -123,7 +123,7 @@ class EndOfDataPDUv1(rpki.rpki_rtr.pdus.EndOfDataPDUv1):
 
 
 @clone_pdu
-class CacheResetPDU(rpki.rpki_rtr.pdus.CacheResetPDU):
+class CacheResetPDU(rpki.rtr.pdus.CacheResetPDU):
   """
   Cache reset PDU.
   """
@@ -138,7 +138,7 @@ class CacheResetPDU(rpki.rpki_rtr.pdus.CacheResetPDU):
     client.push_pdu(ResetQueryPDU(version = client.version))
 
 
-class PrefixPDU(rpki.rpki_rtr.pdus.PrefixPDU):
+class PrefixPDU(rpki.rtr.pdus.PrefixPDU):
   """
   Object representing one prefix.  This corresponds closely to one PDU
   in the rpki-router protocol, so closely that we use lexical ordering
@@ -159,7 +159,7 @@ class PrefixPDU(rpki.rpki_rtr.pdus.PrefixPDU):
 
 
 @clone_pdu
-class IPv4PrefixPDU(PrefixPDU, rpki.rpki_rtr.pdus.IPv4PrefixPDU):
+class IPv4PrefixPDU(PrefixPDU, rpki.rtr.pdus.IPv4PrefixPDU):
   """
   IPv4 flavor of a prefix.
   """
@@ -167,7 +167,7 @@ class IPv4PrefixPDU(PrefixPDU, rpki.rpki_rtr.pdus.IPv4PrefixPDU):
   pass
 
 @clone_pdu
-class IPv6PrefixPDU(PrefixPDU, rpki.rpki_rtr.pdus.IPv6PrefixPDU):
+class IPv6PrefixPDU(PrefixPDU, rpki.rtr.pdus.IPv6PrefixPDU):
   """
   IPv6 flavor of a prefix.
   """
@@ -175,7 +175,7 @@ class IPv6PrefixPDU(PrefixPDU, rpki.rpki_rtr.pdus.IPv6PrefixPDU):
   pass
 
 @clone_pdu
-class RouterKeyPDU(rpki.rpki_rtr.pdus.RouterKeyPDU):
+class RouterKeyPDU(rpki.rtr.pdus.RouterKeyPDU):
   """
   Router Key PDU.
   """
@@ -189,7 +189,7 @@ class RouterKeyPDU(rpki.rpki_rtr.pdus.RouterKeyPDU):
     client.consume_routerkey(self)
 
 
-class ClientChannel(rpki.rpki_rtr.channels.PDUChannel):
+class ClientChannel(rpki.rtr.channels.PDUChannel):
   """
   Client protocol engine, handles upcalls from PDUChannel.
   """
@@ -484,7 +484,7 @@ def client_main(args):
 
   logging.debug("[Startup]")
 
-  constructor = getattr(rpki.rpki_rtr.client.ClientChannel, args.protocol)
+  constructor = getattr(rpki.rtr.client.ClientChannel, args.protocol)
 
   client = None
   try:
diff --git a/rpki/rpki_rtr/generator.py b/rpki/rtr/generator.py
index 2d8f3f76..26e25b6e 100644
--- a/rpki/rpki_rtr/generator.py
+++ b/rpki/rtr/generator.py
@@ -30,13 +30,13 @@ import logging
 import subprocess
 import rpki.POW
 import rpki.oids
-import rpki.rpki_rtr.pdus
-import rpki.rpki_rtr.channels
-import rpki.rpki_rtr.server
+import rpki.rtr.pdus
+import rpki.rtr.channels
+import rpki.rtr.server
 
-from rpki.rpki_rtr.channels import Timestamp
+from rpki.rtr.channels import Timestamp
 
-class PrefixPDU(rpki.rpki_rtr.pdus.PrefixPDU):
+class PrefixPDU(rpki.rtr.pdus.PrefixPDU):
   """
   Object representing one prefix.  This corresponds closely to one PDU
   in the rpki-router protocol, so closely that we use lexical ordering
@@ -100,7 +100,7 @@ class IPv6PrefixPDU(PrefixPDU):
   pdu_type = 6
   address_byte_count = 16
 
-class RouterKeyPDU(rpki.rpki_rtr.pdus.RouterKeyPDU):
+class RouterKeyPDU(rpki.rtr.pdus.RouterKeyPDU):
   """
   Router Key PDU.
   """
@@ -177,7 +177,7 @@ class PDUSet(list):
   """
 
   def __init__(self, version):
-    assert version in rpki.rpki_rtr.pdus.PDU.version_map
+    assert version in rpki.rtr.pdus.PDU.version_map
     super(PDUSet, self).__init__()
     self.version = version
 
@@ -189,9 +189,9 @@ class PDUSet(list):
 
     self = cls(version = version)
     f = open(filename, "rb")
-    r = rpki.rpki_rtr.channels.ReadBuffer()
+    r = rpki.rtr.channels.ReadBuffer()
     while True:
-      p = rpki.rpki_rtr.pdus.PDU.read_pdu(r)
+      p = rpki.rtr.pdus.PDU.read_pdu(r)
       while p is None:
         b = f.read(r.needed())
         if b == "":
@@ -232,9 +232,9 @@ class AXFRSet(PDUSet):
     """
 
     self = cls(version = version)
-    self.serial = rpki.rpki_rtr.channels.Timestamp.now()
+    self.serial = rpki.rtr.channels.Timestamp.now()
 
-    include_routercerts = RouterKeyPDU.pdu_type in rpki.rpki_rtr.pdus.PDU.version_map[version]
+    include_routercerts = RouterKeyPDU.pdu_type in rpki.rtr.pdus.PDU.version_map[version]
 
     if scan_roas is None or (scan_routercerts is None and include_routercerts):
       for root, dirs, files in os.walk(rcynic_dir):     # pylint: disable=W0612
@@ -292,7 +292,7 @@ class AXFRSet(PDUSet):
     assert fn1.isdigit() and fn2 == "ax" and fn3.startswith("v") and fn3[1:].isdigit()
     version = int(fn3[1:])
     self = cls._load_file(filename, version)
-    self.serial = rpki.rpki_rtr.channels.Timestamp(fn1)
+    self.serial = rpki.rtr.channels.Timestamp(fn1)
     return self
 
   def filename(self):
@@ -308,7 +308,7 @@ class AXFRSet(PDUSet):
     Load current AXFRSet.  Return None if can't.
     """
 
-    serial = rpki.rpki_rtr.server.read_current(version)[0]
+    serial = rpki.rtr.server.read_current(version)[0]
     if serial is None:
       return None
     try:
@@ -358,13 +358,13 @@ class AXFRSet(PDUSet):
     the new nonce invalidates all old serial numbers.
     """
 
-    assert self.version in rpki.rpki_rtr.pdus.PDU.version_map
-    old_serial, nonce = rpki.rpki_rtr.server.read_current(self.version)
+    assert self.version in rpki.rtr.pdus.PDU.version_map
+    old_serial, nonce = rpki.rtr.server.read_current(self.version)
     if old_serial is None or self.seq_ge(old_serial, self.serial):
       logging.debug("Creating new nonce and deleting stale data")
       nonce = self.new_nonce(force_zero_nonce)
       self.destroy_old_data()
-    rpki.rpki_rtr.server.write_current(self.serial, nonce, self.version)
+    rpki.rtr.server.write_current(self.serial, nonce, self.version)
 
   def save_ixfr(self, other):
     """
@@ -425,8 +425,8 @@ class IXFRSet(PDUSet):
     assert fn1.isdigit() and fn2 == "ix" and fn3.isdigit() and fn4.startswith("v") and fn4[1:].isdigit()
     version = int(fn4[1:])
     self = cls._load_file(filename, version)
-    self.from_serial = rpki.rpki_rtr.channels.Timestamp(fn3)
-    self.to_serial = rpki.rpki_rtr.channels.Timestamp(fn1)
+    self.from_serial = rpki.rtr.channels.Timestamp(fn3)
+    self.to_serial = rpki.rtr.channels.Timestamp(fn1)
     return self
 
   def filename(self):
@@ -455,14 +455,14 @@ def kick_all(serial):
   """
 
   try:
-    os.stat(rpki.rpki_rtr.server.kickme_dir)
+    os.stat(rpki.rtr.server.kickme_dir)
   except OSError:
-    logging.debug('# Creating directory "%s"', rpki.rpki_rtr.server.kickme_dir)
-    os.makedirs(rpki.rpki_rtr.server.kickme_dir)
+    logging.debug('# Creating directory "%s"', rpki.rtr.server.kickme_dir)
+    os.makedirs(rpki.rtr.server.kickme_dir)
 
   msg = "Good morning, serial %d is ready" % serial
   sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
-  for name in glob.iglob("%s.*" % rpki.rpki_rtr.server.kickme_base):
+  for name in glob.iglob("%s.*" % rpki.rtr.server.kickme_base):
     try:
       logging.debug("# Kicking %s", name)
       sock.sendto(msg, name)
@@ -497,13 +497,13 @@ def cronjob_main(args):
       logging.critical(str(e))
       sys.exit(1)
 
-  for version in sorted(rpki.rpki_rtr.server.PDU.version_map.iterkeys(), reverse = True):
+  for version in sorted(rpki.rtr.server.PDU.version_map.iterkeys(), reverse = True):
 
     logging.debug("# Generating updates for protocol version %d", version)
 
     old_ixfrs = glob.glob("*.ix.*.v%d" % version)
 
-    current = rpki.rpki_rtr.server.read_current(version)[0]
+    current = rpki.rtr.server.read_current(version)[0]
     cutoff = Timestamp.now(-(24 * 60 * 60))
     for f in glob.iglob("*.ax.v%d" % version):
       t = Timestamp(int(f.split(".")[0]))
@@ -511,19 +511,19 @@ def cronjob_main(args):
         logging.debug("# Deleting old file %s, timestamp %s", f, t)
         os.unlink(f)
 
-    pdus = rpki.rpki_rtr.generator.AXFRSet.parse_rcynic(args.rcynic_dir, version, args.scan_roas, args.scan_routercerts)
-    if pdus == rpki.rpki_rtr.generator.AXFRSet.load_current(version):
+    pdus = rpki.rtr.generator.AXFRSet.parse_rcynic(args.rcynic_dir, version, args.scan_roas, args.scan_routercerts)
+    if pdus == rpki.rtr.generator.AXFRSet.load_current(version):
       logging.debug("# No change, new serial not needed")
       continue
     pdus.save_axfr()
     for axfr in glob.iglob("*.ax.v%d" % version):
       if axfr != pdus.filename():
-        pdus.save_ixfr(rpki.rpki_rtr.generator.AXFRSet.load(axfr))
+        pdus.save_ixfr(rpki.rtr.generator.AXFRSet.load(axfr))
     pdus.mark_current(args.force_zero_nonce)
 
     logging.debug("# New serial is %d (%s)", pdus.serial, pdus.serial)
 
-    rpki.rpki_rtr.generator.kick_all(pdus.serial)
+    rpki.rtr.generator.kick_all(pdus.serial)
 
     old_ixfrs.sort()
     for ixfr in old_ixfrs:
@@ -548,12 +548,12 @@ def show_main(args):
   g = glob.glob("*.ax.v*")
   g.sort()
   for f in g:
-    rpki.rpki_rtr.generator.AXFRSet.load(f).show()
+    rpki.rtr.generator.AXFRSet.load(f).show()
 
   g = glob.glob("*.ix.*.v*")
   g.sort()
   for f in g:
-    rpki.rpki_rtr.generator.IXFRSet.load(f).show()
+    rpki.rtr.generator.IXFRSet.load(f).show()
 
 def argparse_setup(subparsers):
   """
diff --git a/rpki/rpki_rtr/main.py b/rpki/rtr/main.py
index 9415f270..e5b50ef5 100644
--- a/rpki/rpki_rtr/main.py
+++ b/rpki/rtr/main.py
@@ -22,15 +22,14 @@ RFC and Internet-Draft repositories near you.
 """
 
 import os
-import sys
 import time
 import logging
 import logging.handlers
 import argparse
 
-from rpki.rpki_rtr.server    import argparse_setup as argparse_setup_server
-from rpki.rpki_rtr.client    import argparse_setup as argparse_setup_client
-from rpki.rpki_rtr.generator import argparse_setup as argparse_setup_generator
+from rpki.rtr.server    import argparse_setup as argparse_setup_server
+from rpki.rtr.client    import argparse_setup as argparse_setup_client
+from rpki.rtr.generator import argparse_setup as argparse_setup_generator
 
 class Formatter(logging.Formatter):
 
diff --git a/rpki/rpki_rtr/pdus.py b/rpki/rtr/pdus.py
index d8921a07..d8921a07 100644
--- a/rpki/rpki_rtr/pdus.py
+++ b/rpki/rtr/pdus.py
diff --git a/rpki/rpki_rtr/server.py b/rpki/rtr/server.py
index f23ef30e..c403541f 100644
--- a/rpki/rpki_rtr/server.py
+++ b/rpki/rtr/server.py
@@ -28,12 +28,12 @@ import logging
 import asyncore
 import rpki.POW
 import rpki.oids
-import rpki.rpki_rtr.pdus
-import rpki.rpki_rtr.channels
+import rpki.rtr.pdus
+import rpki.rtr.channels
 
-from rpki.rpki_rtr.pdus import (clone_pdu_root,
-                                CacheResponsePDU, EndOfDataPDU, CacheResetPDU, CacheResponsePDU,
-                                EndOfDataPDU, CacheResetPDU, CacheResetPDU, SerialNotifyPDU)
+from rpki.rtr.pdus import (clone_pdu_root,
+                           CacheResponsePDU, EndOfDataPDU, CacheResetPDU, CacheResponsePDU,
+                           EndOfDataPDU, CacheResetPDU, CacheResetPDU, SerialNotifyPDU)
 
 
 # Disable incremental updates.  Debugging only, should be False in production.
@@ -44,7 +44,7 @@ kickme_dir  = "sockets"
 kickme_base = os.path.join(kickme_dir, "kickme")
 
 
-class PDU(rpki.rpki_rtr.pdus.PDU):
+class PDU(rpki.rtr.pdus.PDU):
   """
   Generic server PDU.
   """
@@ -79,7 +79,7 @@ clone_pdu = clone_pdu_root(PDU)
 
 
 @clone_pdu
-class SerialQueryPDU(PDU, rpki.rpki_rtr.pdus.SerialQueryPDU):
+class SerialQueryPDU(PDU, rpki.rtr.pdus.SerialQueryPDU):
   """
   Serial Query PDU.
   """
@@ -114,7 +114,7 @@ class SerialQueryPDU(PDU, rpki.rpki_rtr.pdus.SerialQueryPDU):
 
 
 @clone_pdu
-class ResetQueryPDU(PDU, rpki.rpki_rtr.pdus.ResetQueryPDU):
+class ResetQueryPDU(PDU, rpki.rtr.pdus.ResetQueryPDU):
   """
   Reset Query PDU.
   """
@@ -139,7 +139,7 @@ class ResetQueryPDU(PDU, rpki.rpki_rtr.pdus.ResetQueryPDU):
 
 
 @clone_pdu
-class ErrorReportPDU(rpki.rpki_rtr.pdus.ErrorReportPDU):
+class ErrorReportPDU(rpki.rtr.pdus.ErrorReportPDU):
   """
   Error Report PDU.
   """
@@ -200,7 +200,7 @@ class FileProducer(object):
     return self.handle.read(self.buffersize)
 
 
-class ServerWriteChannel(rpki.rpki_rtr.channels.PDUChannel):
+class ServerWriteChannel(rpki.rtr.channels.PDUChannel):
   """
   Kludge to deal with ssh's habit of sometimes (compile time option)
   invoking us with two unidirectional pipes instead of one
@@ -236,7 +236,7 @@ class ServerWriteChannel(rpki.rpki_rtr.channels.PDUChannel):
         raise
 
 
-class ServerChannel(rpki.rpki_rtr.channels.PDUChannel):
+class ServerChannel(rpki.rtr.channels.PDUChannel):
   """
   Server protocol engine, handles upcalls from PDUChannel to
   implement protocol logic.
@@ -480,8 +480,8 @@ def server_main(args):
 
   kickme = None
   try:
-    server = rpki.rpki_rtr.server.ServerChannel(logger = logger)
-    kickme = rpki.rpki_rtr.server.KickmeChannel(server = server)
+    server = rpki.rtr.server.ServerChannel(logger = logger)
+    kickme = rpki.rtr.server.KickmeChannel(server = server)
     asyncore.loop(timeout = None)
   except KeyboardInterrupt:
     sys.exit(0)
diff --git a/setup.py b/setup.py
index 7cec90ae..95cafcdf 100644
--- a/setup.py
+++ b/setup.py
@@ -38,7 +38,7 @@ except ImportError:
 # pylint: disable=W0622
 
 setup_args = dict(
-  name          = "rpkitoolkit",
+  name          = "rpki",
   version       = VERSION,
   description   = "RPKI Toolkit",
   license       = "BSD",
@@ -48,11 +48,15 @@ setup_args = dict(
 
 scripts         = []
 
+# I keep forgetting to update the packages list here.  Could we
+# automate this by looking for __init__.py files in the rpki/ tree?
+# Might have to filter out some rpki.gui.app subdirs.
+
 if autoconf.RP_TARGET == "rp":
   setup_args.update(
     packages    = ["rpki",
                    "rpki.POW",
-                   "rpki.rpki_rtr",
+                   "rpki.rtr",
                    "rpki.irdb",
                    "rpki.gui",
                    "rpki.gui.app",