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

[minion-cvs] Spelling fixes



Update of /home/minion/cvsroot/src/minion/lib/mixminion/server
In directory moria.mit.edu:/tmp/cvs-serv8484/lib/mixminion/server

Modified Files:
	EventStats.py HashLog.py MMTPServer.py Modules.py 
	PacketHandler.py ServerConfig.py ServerKeys.py ServerMain.py 
	ServerQueue.py 
Log Message:
Spelling fixes

Index: EventStats.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/EventStats.py,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- EventStats.py	5 Jun 2003 18:41:40 -0000	1.6
+++ EventStats.py	13 Jul 2003 03:45:35 -0000	1.7
@@ -95,15 +95,15 @@
        We take some pains to avoid flushing the statistics when too
        little time has passed.  We only rotate an aggregated total to disk
        when:
-           - An interval has passsed since the last rotation time
+           - An interval has passed since the last rotation time
          AND
            - We have accumulated events for at least 75% of an interval's
              worth of time.
 
        The second requirement prevents the following unpleasant failure mode:
-           - We set the interval to '1 day'.  At midnight on monday,
+           - We set the interval to '1 day'.  At midnight on Monday,
              we rotate.  At 00:05, we go down.  At 23:55 we come back
-             up.  At midnight at tuesday, we noticing that it's been one
+             up.  At midnight at Tuesday, we noticing that it's been one
              day since the last rotation, and rotate again -- thus making
              a permanent record that reflects 10 minutes worth of traffic,
              potentially exposing more about individual users than we should.
@@ -124,7 +124,7 @@
     # Map from {"count","lastRotation","accumulatedTime"} to the values
     # for those fields.
     def __init__(self, filename, historyFile, interval):
-        """Intializes an EventLog that caches events in 'filename', and
+        """Initializes an EventLog that caches events in 'filename', and
            periodically writes to 'historyFile' every 'interval' seconds."""
         NilEventLog.__init__(self)
         if os.path.exists(filename):

Index: HashLog.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/HashLog.py,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -d -r1.19 -r1.20
--- HashLog.py	10 Jul 2003 20:01:31 -0000	1.19
+++ HashLog.py	13 Jul 2003 03:45:35 -0000	1.20
@@ -3,7 +3,7 @@
 
 """mixminion.server.HashLog
 
-   Persistant memory for the hashed secrets we've seen.  Used by
+   Persistent memory for the hashed secrets we've seen.  Used by
    PacketHandler to prevent replay attacks."""
 
 import binascii
@@ -26,7 +26,7 @@
 # We flush the log every MAX_JOURNAL hashes.
 MAX_JOURNAL = 128
 
-# Lock to pretect _OPEN_HASHLOGS
+# Lock to protect _OPEN_HASHLOGS
 _HASHLOG_DICT_LOCK = threading.RLock()
 # Map from (filename) to (keyid,open HashLog). Needed to implement getHashLog.
 _OPEN_HASHLOGS = {}

Index: MMTPServer.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/MMTPServer.py,v
retrieving revision 1.43
retrieving revision 1.44
diff -u -d -r1.43 -r1.44
--- MMTPServer.py	10 Jul 2003 21:16:05 -0000	1.43
+++ MMTPServer.py	13 Jul 2003 03:45:35 -0000	1.44
@@ -232,7 +232,7 @@
            3. Reading
            4. Writing
            5. Shutting down.
-       Reads procede until either a given number of bytes have been received,
+       Reads proceed until either a given number of bytes have been received,
        or until a provided terminator has been found.  Writes procede until
        a buffer is exhausted.
 
@@ -712,7 +712,7 @@
 NULL_KEYID = "\x00"*20
 
 class DeliverableMessage:
-    """Interface to be impemented by messages deliverable by MMTP """
+    """Interface to be implemented by messages deliverable by MMTP """
     def __init__(self):
         pass
     def getContents(self):
@@ -723,7 +723,7 @@
         raise NotImplementedError
 
 class DeliverablePacket(DeliverableMessage):
-    """Implementation of DelierableMessage.
+    """Implementation of DeliverableMessage.
 
        Wraps a ServerQueue.PendingMessage object for a queue holding
        PacketHandler.RelayPacket objects."""
@@ -738,7 +738,7 @@
         return self.pending.getMessage().getPacket()
 
 class MMTPClientConnection(SimpleTLSConnection):
-    """Asynchronious implementation of the sending ("client") side of a
+    """Asynchronous implementation of the sending ("client") side of a
        mixminion connection."""
     ## Fields:
     # ip, port, keyID, messageList, finishedCallback, certCache:
@@ -1062,7 +1062,7 @@
         """Begin sending a set of messages to a given server.
 
            deliverable is a list of objects obeying the DeliverableMessage
-           lsit.
+           interface.
         """
 
         try:

Index: Modules.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/Modules.py,v
retrieving revision 1.47
retrieving revision 1.48
diff -u -d -r1.47 -r1.48
--- Modules.py	7 Jul 2003 19:27:15 -0000	1.47
+++ Modules.py	13 Jul 2003 03:45:35 -0000	1.48
@@ -47,7 +47,7 @@
        the methods in this class.
 
        A delivery module has the following responsibilities:
-           * It must have a 0-argument contructor.
+           * It must have a 0-argument constructor.
            * If it is configurable, it must be able to specify its options,
              validate its configuration, and configure itself.
            * If it is advertisable, it must provide a server info block.
@@ -112,7 +112,7 @@
                                    retrySchedule=self.getRetrySchedule())
 
     def processMessage(self, packet):
-        """Given a DeliveryPacket object, try to delier it.  Return one of:
+        """Given a DeliveryPacket object, try to deliver it.  Return one of:
             DELIVER_OK (if the message was successfully delivered),
             DELIVER_FAIL_RETRY (if the message wasn't delivered, but might be
               deliverable later), or
@@ -244,7 +244,7 @@
        A module may be in one of three states: unloaded, registered, or
        enabled.  An unloaded module is just a class in a python module.
        A registered module has been loaded, configured, and listed with
-       the ModuleManager, but will not receive messags until it is
+       the ModuleManager, but will not receive messages until it is
        enabled.
 
        Because modules need to tell the ServerConfig object about their
@@ -290,7 +290,7 @@
         self.thread = None
 
     def startThreading(self):
-        """Begin delivering messages in a separte thread.  Should only
+        """Begin delivering messages in a separate thread.  Should only
            be called once."""
         self.thread = DeliveryThread(self)
         self.thread.start()
@@ -404,7 +404,7 @@
 
     def queueDecodedMessage(self, packet):
         """Given a packet of type DeliveryPacket, try to find an appropriate
-           exit module, and queue the packet for delivey by that exit module.
+           exit module, and queue the packet for delivery by that exit module.
         """
         exitType = packet.getExitType()
 
@@ -499,7 +499,7 @@
     #   If the value for a key is 'SUB', all subdomains are also included.
     # users -- A dict whose keys are lowercased users ("foo")
     # patterns -- A list of regular expression objects.
-    # includeStr -- a string the casuses items to get included in this set.
+    # includeStr -- a string the causes items to get included in this set.
     #   defaults to 'deny'
     def __init__(self, fname=None, string=None, includeStr="deny"):
         """Read the address set from a file or a string."""
@@ -886,7 +886,7 @@
 class MixmasterSMTPModule(SMTPModule):
     """Implements SMTP by relaying messages via Mixmaster nodes.  This
        is kind of unreliable and kludgey, but it does allow us to
-       test mixminion by usingg Mixmaster nodes as exits."""
+       test mixminion by using Mixmaster nodes as exits."""
     # (Mixmaster has tons of options, but we ignore them, since
     #  this is only a temporary workaround until enough people
     #  are running SMTP exit nodes.)

Index: PacketHandler.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/PacketHandler.py,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -d -r1.18 -r1.19
--- PacketHandler.py	30 Jun 2003 17:33:33 -0000	1.18
+++ PacketHandler.py	13 Jul 2003 03:45:35 -0000	1.19
@@ -95,7 +95,7 @@
         """Given a 32K mixminion message, processes it completely.
 
            Return one of:
-                    None [if the mesesage should be dropped.]
+                    None [if the message should be dropped.]
                     a DeliveryPacket object
                     a RelayedPacket object
 

Index: ServerConfig.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/ServerConfig.py,v
retrieving revision 1.35
retrieving revision 1.36
diff -u -d -r1.35 -r1.36
--- ServerConfig.py	7 Jul 2003 16:49:25 -0000	1.35
+++ ServerConfig.py	13 Jul 2003 03:45:35 -0000	1.36
@@ -38,7 +38,7 @@
             entries = self._sectionEntries
             return len([e for e in entries[section] if e[0] == ent]) != 0
 
-        # Pre-emptively configure the log before validation, so we don't
+        # Preemptively configure the log before validation, so we don't
         # write to the terminal if we've been asked not to.
         if not self['Server'].get("EchoMessages", 0):
             LOG.handlers = []

Index: ServerKeys.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/ServerKeys.py,v
retrieving revision 1.47
retrieving revision 1.48
diff -u -d -r1.47 -r1.48
--- ServerKeys.py	10 Jul 2003 20:01:31 -0000	1.47
+++ ServerKeys.py	13 Jul 2003 03:45:35 -0000	1.48
@@ -152,8 +152,8 @@
 
     def checkDescriptorConsistency(self, regen=1):
         """Check whether the server descriptors in this keyring are
-           consistent with the server's configuration.  If 'regen' are true,
-           inconsistent descriptors are regenerated."""
+           consistent with the server's configuration.  If 'regen' is
+           true, inconsistent descriptors are regenerated."""
         identity = None
         state = []
         for _,_,ks in self.keySets:
@@ -540,7 +540,7 @@
        to store the keys' lifetimes.
 
        When we create a new ServerKeyset object, the associated keys are not
-       read from disk unil the object's load method is called."""
+       read from disk until the object's load method is called."""
     ## Fields:
     # keydir: Directory to store this keyset's data.
     # hashlogFile: filename of this keyset's hashlog.
@@ -888,7 +888,7 @@
         secure = "yes"
 
     # Calculate descriptor and X509 certificate lifetimes.
-    # (Round validAt to previous mignight.)
+    # (Round validAt to previous midnight.)
     validAt = mixminion.Common.previousMidnight(validAt+30)
     if not validUntil:
         keyLifetime = config['Server']['PublicKeyLifetime'].getSeconds()

Index: ServerMain.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/ServerMain.py,v
retrieving revision 1.84
retrieving revision 1.85
diff -u -d -r1.84 -r1.85
--- ServerMain.py	7 Jul 2003 18:55:15 -0000	1.84
+++ ServerMain.py	13 Jul 2003 03:45:35 -0000	1.85
@@ -25,7 +25,7 @@
 #                     key_0001/ServerDesc [Server descriptor]
 #                              mix.key [packet key]
 #                              mmtp.key [mmtp key]
-#                              mmtp.cert [mmmtp key x509 cert]
+#                              mmtp.cert [mmtp key's x509 cert chain]
 #                              published [present if this desc is published]
 #                     key_0002/...
 #                conf/miniond.conf [configuration file]
@@ -35,7 +35,7 @@
 
 # FFFF Support to put keys/queues in separate directories.
 
-__all__ = [ 'MixminonServer' ]
+__all__ = [ 'MixminionServer' ]
 
 import errno
 import getopt
@@ -594,7 +594,7 @@
     #    periodically decides which ones to deliver, according to some
     #    batching algorithm.
     # moduleManager: Instance of ModuleManager.  Map routing types to
-    #    outging queues, and processes non-MMTP exit messages.
+    #    outgoing queues, and processes non-MMTP exit messages.
     # outgoingQueue: Holds messages waiting to be send via MMTP.
     # cleaningThread: Thread used to remove packets in the background
     # processingThread: Thread to handle CPU-intensive activity without

Index: ServerQueue.py
===================================================================
RCS file: /home/minion/cvsroot/src/minion/lib/mixminion/server/ServerQueue.py,v
retrieving revision 1.24
retrieving revision 1.25
diff -u -d -r1.24 -r1.25
--- ServerQueue.py	26 Jun 2003 03:23:53 -0000	1.24
+++ ServerQueue.py	13 Jul 2003 03:45:35 -0000	1.25
@@ -42,12 +42,12 @@
              inp_HANDLE  (An incomplete message being created.)
 
        (Where HANDLE is a randomly chosen 8-character string of characters
-       chosen from 'A-Za-z0-9+-'.  [Collision probability is negligable, and
+       chosen from 'A-Za-z0-9+-'.  [Collision probability is negligible, and
        collisions are detected.])
 
        Threading notes:  Although Queue itself is threadsafe, you'll want
        to synchronize around any multistep operations that you want to
-       run atomicly.  Use Queue.lock() and Queue.unlock() for this.
+       run atomically.  Use Queue.lock() and Queue.unlock() for this.
 
        In the Mixminion server, no queue currently has more than one producer
        or more than one consumer ... so synchronization turns out to be
@@ -288,7 +288,7 @@
 
 class _DeliveryState:
     """Helper class: holds the state needed to schedule delivery or
-       eventual abandonmont of a message in a DeliveryQueue."""
+       eventual abandonment of a message in a DeliveryQueue."""
     ## Fields:
     # queuedTime: time at which the corresponding message was first
     #    inserted into the queue.
@@ -514,7 +514,7 @@
             if fn.startswith("meta_"):
                 h = fn[5:]
                 if not self.deliveryState.has_key(h):
-                    LOG.warn("Metadata for nonexistant handle %s", h)
+                    LOG.warn("Metadata for nonexistent handle %s", h)
                 os.unlink(os.path.join(self.dir, fn))
 
     def _writeState(self, h):
@@ -823,7 +823,7 @@
         """Create a new queue that yields a batch of message every 'interval'
            seconds, always keeps <minPool> messages in the pool, never sends
            unless it has <minPool>+<minSend> messages, and never sends more
-           than <sendRate> * the corrent pool size.
+           than <sendRate> * the current pool size.
 
            If 'minSend'==1, this is a real Cottrell (type II style) mix pool.
            Otherwise, this is a generic 'timed dynamic-pool' mix pool.  (Note
@@ -835,7 +835,7 @@
         # mixmaster algorithm.  I picked up the other algorithm from an early
         # draft of Roger, Paul, and Andrei's 'Batching Taxonomy' paper (since
         # corrected); they seem to have gotten it from Anja Jerichow's
-        # Phd. thesis ("Generalisation and Security Improvement of
+        # Phd. thesis ("Generalization and Security Improvement of
         # Mix-mediated Anonymous Communication") of 2000.
         #
         # *THIS* is the algorithm that the current 'Batching Taxonomy' paper