Merge pull request #104 from jacomago/refactor-renames

Rename shorter variables to longer more descriptive ones

Author: jacomago

server/recceiver/announce.py

@@ -52,7 +52,7 @@ def stopProtocol(self):
         self.D.cancel()
         del self.D
 
-    def datagramReceived(self, src):
+    def datagramReceived(self, source_address):
         pass  # ignore
 
     def sendOne(self):

server/recceiver/cfstore.py

@@ -84,79 +84,91 @@ def cleanupDB(self, cur):
         cur.execute("PRAGMA foreign_keys = ON;")
         cur.execute("DELETE FROM %s WHERE owner=?" % self.tserver, self.mykey)
 
-    def commit(self, TR):
-        return self.pool.runInteraction(self._commit, TR)
+    def commit(self, transaction):
+        return self.pool.runInteraction(self._commit, transaction)
 
-    def _commit(self, cur, TR):
+    def _commit(self, cur, transaction):
         cur.execute("PRAGMA foreign_keys = ON;")
 
-        if not TR.initial:
-            srvid = self.sources[TR.srcid]
+        if not transaction.initial:
+            srvid = self.sources[transaction.srcid]
         else:
             cur.execute(
                 "INSERT INTO %s (hostname,port,owner) VALUES (?,?,?)" % self.tserver,
-                (TR.src.host, TR.src.port, self.mykey),
+                (
+                    transaction.source_address.host,
+                    transaction.source_address.port,
+                    self.mykey,
+                ),
             )
             cur.execute(
                 "SELECT id FROM %s WHERE hostname=? AND port=? AND owner=?" % self.tserver,
-                (TR.src.host, TR.src.port, self.mykey),
+                (
+                    transaction.source_address.host,
+                    transaction.source_address.port,
+                    self.mykey,
+                ),
             )
             R = cur.fetchone()
             srvid = R[0]
-            self.sources[TR.srcid] = srvid
+            self.sources[transaction.srcid] = srvid
 
-        if not TR.connected:
+        if not transaction.connected:
             cur.execute(
                 "DELETE FROM %s where id=? AND owner=?" % self.tserver,
                 (srvid, self.mykey),
             )
-            del self.sources[TR.srcid]
+            del self.sources[transaction.srcid]
             return
 
-        # update client-wide infos
+        # update client-wide client_infos
         cur.executemany(
             "INSERT OR REPLACE INTO %s (host,key,value) VALUES (?,?,?)" % self.tinfo,
-            [(srvid, K, V) for K, V in TR.infos.items()],
+            [(srvid, K, V) for K, V in transaction.client_infos.items()],
         )
 
         # Remove all records, including those which will be re-created
         cur.executemany(
             "DELETE FROM %s WHERE host=? AND id=?" % self.trecord,
             itertools.chain(
-                [(srvid, recid) for recid in TR.addrec],
-                [(srvid, recid) for recid in TR.delrec],
+                [(srvid, recid) for recid in transaction.records_to_add],
+                [(srvid, recid) for recid in transaction.records_to_delete],
             ),
         )
 
         # Start new records
         cur.executemany(
-            "INSERT INTO %s (host, id, rtype) VALUES (?,?,?)" % self.trecord,
-            [(srvid, recid, rtype) for recid, (rname, rtype) in TR.addrec.items()],
+            "INSERT INTO %s (host, id, record_type) VALUES (?,?,?)" % self.trecord,
+            [(srvid, recid, record_type) for recid, (record_name, record_type) in transaction.records_to_add.items()],
         )
 
         # Add primary record names
         cur.executemany(
-            """INSERT INTO %s (rec, rname, prim) VALUES (
+            """INSERT INTO %s (rec, record_name, prim) VALUES (
                          (SELECT pkey FROM %s WHERE id=? AND host=?)
                          ,?,1)"""
             % (self.tname, self.trecord),
-            [(recid, srvid, rname) for recid, (rname, rtype) in TR.addrec.items()],
+            [(recid, srvid, record_name) for recid, (record_name, record_type) in transaction.records_to_add.items()],
         )
 
         # Add new record aliases
         cur.executemany(
-            """INSERT INTO %(name)s (rec, rname, prim) VALUES (
+            """INSERT INTO %(name)s (rec, record_name, prim) VALUES (
                          (SELECT pkey FROM %(rec)s WHERE id=? AND host=?)
                          ,?,0)"""
             % {"name": self.tname, "rec": self.trecord},
-            [(recid, srvid, rname) for recid, names in TR.aliases.items() for rname in names],
+            [(recid, srvid, record_name) for recid, names in transaction.aliases.items() for record_name in names],
         )
 
-        # add record infos
+        # add record client_infos
         cur.executemany(
             """INSERT OR REPLACE INTO %s (rec,key,value) VALUES (
                          (SELECT pkey FROM %s WHERE id=? AND host=?)
                          ,?,?)"""
             % (self.trecinfo, self.trecord),
-            [(recid, srvid, K, V) for recid, infos in TR.recinfos.items() for K, V in infos.items()],
+            [
+                (recid, srvid, K, V)
+                for recid, client_infos in transaction.record_infos_to_add.items()
+                for K, V in client_infos.items()
+            ],
         )

server/recceiver/dbstore.py

@@ -6,17 +6,17 @@
 
 
 class ITransaction(Interface):
-    src = Attribute("Source Address.")
+    source_address = Attribute("Source Address.")
 
-    addrec = Attribute("""Records being added
+    records_to_add = Attribute("""Records being added
     {recid: ('recname', 'rectype', {'key':'val'})}
     """)
 
-    delrec = Attribute("A set() of recids which are being removed")
+    records_to_delete = Attribute("A set() of recids which are being removed")
 
-    infos = Attribute("A dictionary of new client wide infos")
+    client_infos = Attribute("A dictionary of new client wide infos")
 
-    recinfos = Attribute("""Additional infos being added to existing records
+    record_infos_to_add = Attribute("""Additional infos being added to existing records
     recid: {'key':'val'}
     """)
 

server/recceiver/interfaces.py

@@ -158,16 +158,18 @@ def releaseLock(result):
 
     def _commit(self, trans):
         _log.debug("# Show processor '{name}' commit".format(name=self.name))
-        _log.info("# From {host}:{port}".format(host=trans.src.host, port=trans.src.port))
+        _log.info("# From {host}:{port}".format(host=trans.source_address.host, port=trans.source_address.port))
         if not trans.connected:
             _log.info("#  connection lost")
-        for item in trans.infos.items():
+        for item in trans.client_infos.items():
             _log.info(" epicsEnvSet('{name}','{value}')".format(name=item[0], value=item[1]))
-        for rid, (rname, rtype) in trans.addrec.items():
-            _log.info(' record({rtype}, "{rname}") {{'.format(rtype=rtype, rname=rname))
-            for alias in trans.aliases.get(rid, []):
+        for record_id, (record_name, record_type) in trans.records_to_add.items():
+            _log.info(
+                ' record({record_type}, "{record_name}") {{'.format(record_type=record_type, record_name=record_name)
+            )
+            for alias in trans.aliases.get(record_id, []):
                 _log.info('  alias("{alias}")'.format(alias=alias))
-            for item in trans.recinfos.get(rid, {}).items():
+            for item in trans.record_infos_to_add.get(record_id, {}).items():
                 _log.info('  info({name},"{value}")'.format(name=item[0], value=[1]))
             _log.info(" }")
             yield
@@ -183,8 +185,8 @@ class ProcessorFactory(object):
     name = None
     processor = None
 
-    def __init__(self, name, proc):
-        self.name, self.processor = name, proc
+    def __init__(self, name, processor):
+        self.name, self.processor = name, processor
 
     def build(self, name, opts):
         P = self.processor(name, opts)

server/recceiver/processors.py

@@ -145,43 +145,43 @@ def recvPong(self, body):
 
     # 0x0006
     def recvInfo(self, body):
-        rid, klen, vlen = _c_info.unpack(body[: _c_info.size])
+        record_id, klen, vlen = _c_info.unpack(body[: _c_info.size])
         text = body[_c_info.size :]
         text = text.decode()
         if klen == 0 or klen + vlen < len(text):
             _log.error("Ignoring info update")
             return self.getInitialState()
         key = text[:klen]
         val = text[klen : klen + vlen]
-        if rid:
-            self.sess.recInfo(rid, key, val)
+        if record_id:
+            self.sess.recInfo(record_id, key, val)
         else:
             self.sess.iocInfo(key, val)
         return self.getInitialState()
 
     # 0x0003
     def recvAddRec(self, body):
-        rid, rtype, rtlen, rnlen = _c_rec.unpack(body[: _c_rec.size])
+        record_id, record_type, rtlen, rnlen = _c_rec.unpack(body[: _c_rec.size])
         text = body[_c_rec.size :]
         text = text.decode()
         if rnlen == 0 or rtlen + rnlen < len(text):
             _log.error("Ignoring record update")
 
-        elif rtlen > 0 and rtype == 0:  # new record
+        elif rtlen > 0 and record_type == 0:  # new record
             rectype = text[:rtlen]
             recname = text[rtlen : rtlen + rnlen]
-            self.sess.addRecord(rid, rectype, recname)
+            self.sess.addRecord(record_id, rectype, recname)
 
-        elif rtype == 1:  # record alias
+        elif record_type == 1:  # record alias
             recname = text[rtlen : rtlen + rnlen]
-            self.sess.addAlias(rid, recname)
+            self.sess.addAlias(record_id, recname)
 
         return self.getInitialState()
 
     # 0x0004
     def recvDelRec(self, body):
-        rid = _ping.unpack(body[: _ping.size])
-        self.sess.delRecord(rid)
+        record_id = _ping.unpack(body[: _ping.size])
+        self.sess.delRecord(record_id)
         return self.getInitialState()
 
     # 0x0005
@@ -194,10 +194,13 @@ def recvDone(self, body):
         elapsed_s = time.time() - self.uploadStart
         size_kb = self.uploadSize / 1024
         rate_kbs = size_kb / elapsed_s
-        src = "{}:{}".format(self.sess.ep.host, self.sess.ep.port)
+        source_address = "{}:{}".format(self.sess.ep.host, self.sess.ep.port)
         _log.info(
-            "Done message from {src}: uploaded {size_kb}kB in {elapsed_s}s ({rate_kbs}kB/s)".format(
-                src=src, size_kb=size_kb, elapsed_s=elapsed_s, rate_kbs=rate_kbs
+            "Done message from {source_address}: uploaded {size_kb}kB in {elapsed_s}s ({rate_kbs}kB/s)".format(
+                source_address=source_address,
+                size_kb=size_kb,
+                elapsed_s=elapsed_s,
+                rate_kbs=rate_kbs,
             )
         )
 
@@ -216,26 +219,26 @@ class Transaction(object):
     def __init__(self, ep, id):
         self.connected = True
         self.initial = False
-        self.src = ep
+        self.source_address = ep
         self.srcid = id
-        self.addrec, self.infos, self.recinfos = {}, {}, {}
+        self.records_to_add, self.client_infos, self.record_infos_to_add = {}, {}, {}
         self.aliases = collections.defaultdict(list)
-        self.delrec = set()
+        self.records_to_delete = set()
 
     def show(self, fp=sys.stdout):
         _log.info(str(self))
 
     def __str__(self):
-        src = "{}:{}".format(self.src.host, self.src.port)
+        source_address = "{}:{}".format(self.source_address.host, self.source_address.port)
         init = self.initial
         conn = self.connected
-        nenv = len(self.infos)
-        nadd = len(self.addrec)
-        ndel = len(self.delrec)
-        ninfo = len(self.recinfos)
+        nenv = len(self.client_infos)
+        nadd = len(self.records_to_add)
+        ndel = len(self.records_to_delete)
+        ninfo = len(self.record_infos_to_add)
         nalias = len(self.aliases)
         return "Transaction(Src:{}, Init:{}, Conn:{}, Env:{}, Rec:{}, Alias:{}, Info:{}, Del:{})".format(
-            src, init, conn, nenv, nadd, nalias, ninfo, ndel
+            source_address, init, conn, nenv, nadd, nalias, ninfo, ndel
         )
 
 
@@ -249,8 +252,8 @@ def __init__(self, proto, endpoint):
         _log.info("Open session from {endpoint}".format(endpoint=endpoint))
         self.reactor = reactor
         self.proto, self.ep = proto, endpoint
-        self.TR = Transaction(self.ep, id(self))
-        self.TR.initial = True
+        self.transaction = Transaction(self.ep, id(self))
+        self.transaction.initial = True
         self.C = defer.succeed(None)
         self.T = None
         self.dirty = False
@@ -267,8 +270,8 @@ def suppressCancelled(err):
 
         # Clear the current transaction and
         # commit an empty one for disconnect.
-        self.TR = Transaction(self.ep, id(self))
-        self.TR.connected = False
+        self.transaction = Transaction(self.ep, id(self))
+        self.transaction.connected = False
         self.dirty = True
         self.flush()
 
@@ -278,16 +281,16 @@ def flush(self, connected=True):
         if not self.dirty:
             return
 
-        TR, self.TR = self.TR, Transaction(self.ep, id(self))
+        transaction, self.transaction = self.transaction, Transaction(self.ep, id(self))
         self.dirty = False
 
         def commit(_ignored):
-            _log.info("Commit: {TR}".format(TR=TR))
-            return defer.maybeDeferred(self.factory.commit, TR)
+            _log.info("Commit: {transaction}".format(transaction=transaction))
+            return defer.maybeDeferred(self.factory.commit, transaction)
 
         def abort(err):
             if err.check(defer.CancelledError):
-                _log.info("Commit cancelled: {TR}".format(TR=TR))
+                _log.info("Commit cancelled: {transaction}".format(transaction=transaction))
                 return err
             else:
                 _log.error("Commit failure: {err}".format(err=err))
@@ -302,7 +305,9 @@ def abort(err):
     def flushSafely(self):
         if self.T and self.T <= time.time():
             self.flush()
-        elif self.trlimit and self.trlimit <= (len(self.TR.addrec) + len(self.TR.delrec)):
+        elif self.trlimit and self.trlimit <= (
+            len(self.transaction.records_to_add) + len(self.transaction.records_to_delete)
+        ):
             self.flush()
 
     def markDirty(self):
@@ -314,32 +319,32 @@ def done(self):
         self.flush()
 
     def iocInfo(self, key, val):
-        self.TR.infos[key] = val
+        self.transaction.client_infos[key] = val
         self.markDirty()
 
-    def addRecord(self, rid, rtype, rname):
+    def addRecord(self, record_id, record_type, record_name):
         self.flushSafely()
-        self.TR.addrec[rid] = (rname, rtype)
+        self.transaction.records_to_add[record_id] = (record_name, record_type)
         self.markDirty()
 
-    def addAlias(self, rid, rname):
-        self.TR.aliases[rid].append(rname)
+    def addAlias(self, record_id, record_name):
+        self.transaction.aliases[record_id].append(record_name)
         self.markDirty()
 
-    def delRecord(self, rid):
+    def delRecord(self, record_id):
         self.flushSafely()
-        self.TR.addrec.pop(rid, None)
-        self.TR.delrec.add(rid)
-        self.TR.recinfos.pop(rid, None)
+        self.transaction.records_to_add.pop(record_id, None)
+        self.transaction.records_to_delete.add(record_id)
+        self.transaction.record_infos_to_add.pop(record_id, None)
         self.markDirty()
 
-    def recInfo(self, rid, key, val):
+    def recInfo(self, record_id, key, val):
         try:
-            infos = self.TR.recinfos[rid]
+            client_infos = self.transaction.record_infos_to_add[record_id]
         except KeyError:
-            infos = {}
-            self.TR.recinfos[rid] = infos
-        infos[key] = val
+            client_infos = {}
+            self.transaction.record_infos_to_add[record_id] = client_infos
+        client_infos[key] = val
         self.markDirty()