python3 updates

nando

@@ -5,40 +5,91 @@ import socket,sys,time,os,configobj
 RC = "/etc/nandorc"
 BLOCK_SIZE = 10240
 
+
 def setup_options():
-    ''' Setup the command line options '''
+    """ Setup the command line options """
     from argparse import ArgumentParser
 
-    parser=ArgumentParser(description="Alive notifier. Options first read from /etc/nandorc, and overriden by switches.")
+    parser = ArgumentParser(
-    parser.add_argument("--host",action='store', dest='HOST',type=str,default=None,
+        description="Alive notifier. Options first read from /etc/nandorc, and overriden by switches."
-                      help="Host name/IP of the server")
+    )
-    parser.add_argument("--port", action='store', dest='PORT', default=None,type=int,
+    parser.add_argument(
-                      help="Port number of the server")
+        "--host",
-    parser.add_argument("-t",action='store', dest='TIMEOUT',default=5, type=int,
+        action="store",
-                      help="Connection timeout")
+        dest="HOST",
-    parser.add_argument("-i",action='store', dest='INTERVAL',default=0, type=int,
+        type=str,
-                      help="Send signal every i seconds. If 0, send only once and exit.")
+        default=None,
-    parser.add_argument("-m",action='store', dest='MSGFILE',type=str,default=None,
+        help="Host name/IP of the server",
-                      help="Read a text file as description. Max length 512 chars")
+    )
-    parser.add_argument("--query-ip",action='store', dest='QUERY_HOSTNAME',default=None,type=str,
+    parser.add_argument(
-                      help="Query the IP of a host name")
+        "--port",
-    parser.add_argument("--query-host",action='store', dest='QUERY_IP',default=None,type=str,
+        action="store",
-                      help="Query the hostname of an IP")
+        dest="PORT",
-    parser.add_argument("command",type=str,action="store",default="",nargs="?",
+        default=None,
-                      choices=['','list','alive','lost'],
+        type=int,
-                      help="Command to send. If empty, send standard alive-notice. Commands: list, alive")
+        help="Port number of the server",
+    )
+    parser.add_argument(
+        "-t",
+        action="store",
+        dest="TIMEOUT",
+        default=5,
+        type=int,
+        help="Connection timeout",
+    )
+    parser.add_argument(
+        "-i",
+        action="store",
+        dest="INTERVAL",
+        default=0,
+        type=int,
+        help="Send signal every i seconds. If 0, send only once and exit.",
+    )
+    parser.add_argument(
+        "-m",
+        action="store",
+        dest="MSGFILE",
+        type=str,
+        default=None,
+        help="Read a text file as description. Max length 512 chars",
+    )
+    parser.add_argument(
+        "--query-ip",
+        action="store",
+        dest="QUERY_HOSTNAME",
+        default=None,
+        type=str,
+        help="Query the IP of a host name",
+    )
+    parser.add_argument(
+        "--query-host",
+        action="store",
+        dest="QUERY_IP",
+        default=None,
+        type=str,
+        help="Query the hostname of an IP",
+    )
+    parser.add_argument(
+        "command",
+        type=str,
+        action="store",
+        default="",
+        nargs="?",
+        choices=["", "list", "alive", "lost"],
+        help="Command to send. If empty, send standard alive-notice. Commands: list, alive",
+    )
     options = parser.parse_args()
     if os.path.exists(RC):
         rc = configobj.ConfigObj(RC)
         if options.HOST is None:
             if "HOST" in rc.keys():
-                options.HOST=rc['HOST']
+                options.HOST = rc["HOST"]
         if options.PORT is None:
             if "PORT" in rc.keys():
-                options.PORT=int(rc['PORT'])
+                options.PORT = int(rc["PORT"])
         if options.MSGFILE is None:
             if "MSGFILE" in rc.keys():
-                options.MSGFILE=rc['MSGFILE']
+                options.MSGFILE = rc["MSGFILE"]
 
     if options.HOST is None:
         parser.error("Host name required")
@@ -60,7 +111,18 @@ def print_table(data):
         cols = row.split("|", 4)
         if len(cols) != 4:
             continue
-        print(("{0:<"+lengths[0]+"} | {1:<"+lengths[1]+"} | {2:>"+lengths[2]+"} | {3}").format(*cols))
+        print(
+            (
+                "{0:<"
+                + lengths[0]
+                + "} | {1:<"
+                + lengths[1]
+                + "} | {2:>"
+                + lengths[2]
+                + "} | {3}"
+            ).format(*cols)
+        )
+
 
 def query_ip(sock, opts):
     sock.sendto("list", (opts.HOST, opts.PORT))
@@ -72,6 +134,7 @@ def query_ip(sock,opts):
             sys.exit(0)
     sys.exit(1)
 
+
 def query_host(sock, opts):
     sock.sendto("list", (opts.HOST, opts.PORT))
     received = sock.recv(BLOCK_SIZE)
@@ -82,6 +145,7 @@ def query_host(sock,opts):
             sys.exit(0)
     sys.exit(1)
 
+
 def read_desc(opts):
 
     if not opts.MSGFILE:
@@ -90,9 +154,10 @@ def read_desc(opts):
         return ""
 
     DESC = open(opts.MSGFILE, "rb").read(1024)
-    DESC=''.join([ str(c) for c in DESC.decode('utf-8') if c not in ['\n','\r','|'] ])
+    DESC = "".join([str(c) for c in DESC.decode("utf-8") if c not in ["\n", "\r", "|"]])
     return DESC
 
+
 opts = setup_options()
 
 errors = 0
@@ -115,14 +180,14 @@ while True:
         else:
             MSG = opts.command
 
-        sock.sendto(MSG.encode('utf8'), (opts.HOST, opts.PORT))
+        sock.sendto(MSG.encode("utf8"), (opts.HOST, opts.PORT))
         received = sock.recv(BLOCK_SIZE)
         if opts.command != "":
-            print_table(received.decode('utf8'))
+            print_table(received.decode("utf8"))
         if opts.INTERVAL == 0 and opts.command == "":
-            sock.sendto("list".encode('utf8'), (opts.HOST, opts.PORT))
+            sock.sendto("list".encode("utf8"), (opts.HOST, opts.PORT))
             received = sock.recv(BLOCK_SIZE)
-            print_table(received.decode('utf8'))
+            print_table(received.decode("utf8"))
         errors = 0
     except socket.error:
         print("Didn't get reply from {0}:{1}".format(opts.HOST, opts.PORT))

nandod

@@ -1,37 +1,69 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
-import SocketServer,threading
+import socketserver, threading
 import sqlite3
 import time, os, sys
 
 ALIVE = 60 * 30
 TABLE_HEAD = "Host|IP|Age(d h:m:s)|Description\n"
 
+
 def setup_options():
-    ''' Setup the command line options '''
+    """ Setup the command line options """
     from argparse import ArgumentParser
 
     parser = ArgumentParser(description="Alive notifier.")
-    parser.add_argument("--host",action='store', dest='HOST',default='0.0.0.0',type=str,
+    parser.add_argument(
-                      help="Bind to address: %(default)s")
+        "--host",
-    parser.add_argument("--port", action='store', dest='PORT', default=13370,type=int,
+        action="store",
-                      help="Bind to port: %(default)s")
+        dest="HOST",
-    parser.add_argument("--html-port", action='store', dest='WEBPORT', default=13370,type=int,
+        default="0.0.0.0",
-                      help="Bind www server to port. 0 to disable, default: %(default)s")
+        type=str,
-    parser.add_argument("--db",action='store', dest='DB',default='/tmp/nando.sqlite',type=str,
+        help="Bind to address: %(default)s",
-                      help="Sqlite file for database: %(default)s")
+    )
-    parser.add_argument("--quiet","-q",action='store_true', dest='quiet',default=False,
+    parser.add_argument(
-                      help="Quiet operation: %(default)s")
+        "--port",
+        action="store",
+        dest="PORT",
+        default=13370,
+        type=int,
+        help="Bind to port: %(default)s",
+    )
+    parser.add_argument(
+        "--html-port",
+        action="store",
+        dest="WEBPORT",
+        default=13370,
+        type=int,
+        help="Bind www server to port. 0 to disable, default: %(default)s",
+    )
+    parser.add_argument(
+        "--db",
+        action="store",
+        dest="DB",
+        default="/tmp/nando.sqlite",
+        type=str,
+        help="Sqlite file for database: %(default)s",
+    )
+    parser.add_argument(
+        "--quiet",
+        "-q",
+        action="store_true",
+        dest="quiet",
+        default=False,
+        help="Quiet operation: %(default)s",
+    )
     options = parser.parse_args()
     return options
 
 
-class UDPHandler(SocketServer.BaseRequestHandler):
+class UDPHandler(socketserver.BaseRequestHandler):
     def handle(self):
-        data = self.request[0].strip()
+        DB = DataBase(opts.DB)
+        data = self.request[0].decode("utf-8").strip()
         socket = self.request[1]
         if not opts.quiet:
-            print "{0} wrote: {1}".format(self.client_address[0],data)
+            print(("{0} wrote: {1}".format(self.client_address[0], data)))
         if data == "list":
             reply = DB.list_all()
         elif data == "alive":
@@ -41,19 +73,24 @@ class UDPHandler(SocketServer.BaseRequestHandler):
         else:
             DB.update(data)
             reply = "OK"
-        socket.sendto(reply, self.client_address)
+        socket.sendto(reply.encode("utf-8"), self.client_address)
+        DB.close()
 
-class TCPHandler(SocketServer.BaseRequestHandler):
+
+class TCPHandler(socketserver.BaseRequestHandler):
     def handle(self):
+        HTMLDB = DataBase(opts.DB)
         if not opts.quiet:
-            print "TCP request: {0}".format(self.client_address[0])
+            print(("TCP request: {0}".format(self.client_address[0])))
-        self.data = self.request.recv(1024).strip()
+        self.data = self.request.recv(1024).decode("utf-8").strip()
         method, path, _ = self.data.splitlines()[0].split()
         self.path = path.lstrip("/")
-        self.request.send('HTTP/1.0 200 OK\r\n')
+        self.request.send(b"HTTP/1.0 200 OK\r\n")
-        self.request.send("Content-Type: text/html\r\n\r\n")
+        self.request.send(b"Content-Type: text/html\r\n\r\n")
-        self.request.sendall(HTMLDB.HTML_list(self.path))
+        self.request.sendall(HTMLDB.HTML_list(self.path).encode("utf-8"))
         self.request.close()
+        HTMLDB.close()
+
 
 class DataBase:
     def __init__(self, DB):
@@ -64,6 +101,9 @@ class DataBase:
             self.createDB()
         self.conn_init()
 
+    def close(self):
+        self.conn.close()
+
     def conn_init(self):
         self.conn = sqlite3.connect(self.DBfile)
         self.db = self.conn.cursor()
@@ -75,40 +115,52 @@ class DataBase:
 
     def createDB(self):
         self.conn_init()
-        self.db.execute('CREATE TABLE alive (id TEXT PRIMARY KEY,\
+        self.db.execute(
+            "CREATE TABLE alive (id TEXT PRIMARY KEY,\
                     ip TEXT,\
                     desc TEXT,\
-                    date INTEGER)')
+                    date INTEGER)"
+        )
         self.conn_end()
 
     def update(self, id):
         try:
             host, ip, desc = id.split("|", 3)
-            desc=''.join([ c for c in desc if c not in ['\n','\r','|'] ])
+            desc = "".join([c for c in desc if c not in ["\n", "\r", "|"]])
             if len(ip.split(".")) != 4:
                 return 1
         except:
             return
         self.db = self.conn.cursor()
         if desc is "":
-            self.db.execute("INSERT OR REPLACE INTO alive(id,ip,date) \
+            self.db.execute(
-               VALUES(?,?,?)",(host,ip,int(time.time())))
+                "INSERT OR REPLACE INTO alive(id,ip,date) \
+               VALUES(?,?,?)",
+                (host, ip, int(time.time())),
+            )
         else:
-            self.db.execute("INSERT OR REPLACE INTO alive(id,ip,date,desc) \
+            self.db.execute(
-               VALUES(?,?,?,?)",(host,ip,int(time.time()),desc))
+                "INSERT OR REPLACE INTO alive(id,ip,date,desc) \
+               VALUES(?,?,?,?)",
+                (host, ip, int(time.time()), desc),
+            )
         self.conn_end()
 
     def list_all(self):
         self.db = self.conn.cursor()
-        self.db.execute("SELECT id,ip,date,desc FROM alive ORDER BY id")
+        self.db.execute("SELECT id,ip,date,desc FROM alive ORDER BY date DESC")
         alive = []
         lost = []
         for row in self.db:
             age = int(time.time()) - row[2]
             if age < ALIVE:
-                alive.append("{0}|{1}|{2}|{3}".format(row[0],row[1], humanize_time(age),row[3]))
+                alive.append(
+                    "{0}|{1}|{2}|{3}".format(row[0], row[1], humanize_time(age), row[3])
+                )
             else:
-                lost.append( "{0}|{1}|{2}|{3}".format(row[0],row[1], humanize_time(age),row[3]))
+                lost.append(
+                    "{0}|{1}|{2}|{3}".format(row[0], row[1], humanize_time(age), row[3])
+                )
         return TABLE_HEAD + "\n".join(alive) + "\n---|---|---|---\n" + "\n".join(lost)
 
     def list_alive(self):
@@ -118,7 +170,9 @@ class DataBase:
         for row in self.db:
             age = int(time.time()) - row[2]
             if age < ALIVE:
-                msg.append("{0}|{1}|{2}|{3}".format(row[0],row[1], humanize_time(age),row[3]))
+                msg.append(
+                    "{0}|{1}|{2}|{3}".format(row[0], row[1], humanize_time(age), row[3])
+                )
         return TABLE_HEAD + "\n".join(msg)
 
     def list_lost(self):
@@ -128,13 +182,16 @@ class DataBase:
         for row in self.db:
             age = int(time.time()) - row[2]
             if age >= ALIVE:
-                msg.append("{0}|{1}|{2}|{3}".format(row[0],row[1], humanize_time(age),row[3]))
+                msg.append(
+                    "{0}|{1}|{2}|{3}".format(row[0], row[1], humanize_time(age), row[3])
+                )
         return TABLE_HEAD + "\n".join(msg)
 
     def HTML_list(self, name):
         # name = ''  means do not filter by name
         msg = []
-        msg.append('''<html>
+        msg.append(
+            """<html>
 <head>
 <style>
 body {
@@ -153,78 +210,115 @@ td, th {
 }
 </style>
 </head>
-<body><h1>Alive</h1><table>''')
+<body><h1>Alive</h1><table>"""
+        )
         self.db = self.conn.cursor()
         self.db.execute("SELECT id,ip,date,desc FROM alive ORDER BY id")
-        msg.append('<tr><th>{0}</th><th>{1}</th><th class="right">{2}</th><th>{3}</th></tr>'.format('Host','IP','Age[d h:m:s]','Description'))
+        msg.append(
+            '<tr><th>{0}</th><th>{1}</th><th class="right">{2}</th><th>{3}</th></tr>'.format(
+                "Host", "IP", "Age[d h:m:s]", "Description"
+            )
+        )
         for row in self.db:
-            if name != '':
+            if name != "":
                 if name != row[0]:
                     continue
             age = int(time.time()) - row[2]
             if age < ALIVE:
-                msg.append('<tr><td>{0}</td><td>{1}</td><td class="right">{2}</td><td>{3}</td></tr>'.format(row[0],row[1],humanize_time(age),row[3]))
+                msg.append(
-        msg.append('</table><h1>Lost</h1><table>')
+                    '<tr><td>{0}</td><td>{1}</td><td class="right">{2}</td><td>{3}</td></tr>'.format(
-        msg.append('<tr><th>{0}</th><th>{1}</th><th class="right">{2}</th><th>{3}</th></tr>'.format('Host','IP','Age[d h:m:s]','Description'))
+                        row[0], row[1], humanize_time(age), row[3]
+                    )
+                )
+        msg.append("</table><h1>Lost</h1><table>")
+        msg.append(
+            '<tr><th>{0}</th><th>{1}</th><th class="right">{2}</th><th>{3}</th></tr>'.format(
+                "Host", "IP", "Age[d h:m:s]", "Description"
+            )
+        )
         self.db.execute("SELECT id,ip,date,desc FROM alive ORDER BY id")
         for row in self.db:
-            if name != '':
+            if name != "":
                 if name != row[0]:
                     continue
             age = int(time.time()) - row[2]
             if age >= ALIVE:
-                msg.append('<tr><td>{0}</td><td>{1}</td><td class="right">{2}</td><td>{3}</td></tr>'.format(row[0],row[1],humanize_time(age),row[3]))
+                msg.append(
-        msg.append('</table></body></html>')
+                    '<tr><td>{0}</td><td>{1}</td><td class="right">{2}</td><td>{3}</td></tr>'.format(
+                        row[0], row[1], humanize_time(age), row[3]
+                    )
+                )
+        msg.append("</table></body></html>")
 
         return "\n\r".join(msg)
 
-def UDPserve():
+class UDPServe:
-    global DB
+    def __init__(self, opts):
-    global server
+        self.server = socketserver.UDPServer((opts.HOST, opts.PORT), UDPHandler)
-    DB=DataBase(opts.DB)
+
-    server = SocketServer.UDPServer((opts.HOST, opts.PORT), UDPHandler)
+    def start(self):
-    server.serve_forever()
+        thread = threading.Thread(target=self.serve)
-def TCPserve():
+        thread.daemon = True
-    global HTMLDB
+        thread.start()
-    global HTMLserver
+
+    def serve(self):
+        self.server.serve_forever()
+
+    def stop(self):
+        self.server.shutdown()
+        self.server.server_close()
+
+
+class TCPServe:
+    def __init__(self, opts):
+        self.server = socketserver.TCPServer((opts.HOST, opts.WEBPORT), TCPHandler)
+
+    def start(self):
+        thread = threading.Thread(target=self.serve)
+        thread.daemon = True
+        thread.start()
+
+    def serve(self):
         time.sleep(2)
-    try:
+        self.server.serve_forever()
-        HTMLDB=DataBase(opts.DB)
+
-        HTMLserver = SocketServer.TCPServer((opts.HOST, opts.WEBPORT), TCPHandler)
+    def stop(self):
-        HTMLserver.serve_forever()
+        self.server.shutdown()
-    except:
+        self.server.server_close()
-        sys.exit(1)
+
+
 
 def humanize_time(secs):
     mins, secs = divmod(secs, 60)
     hours, mins = divmod(mins, 60)
     if hours < 24:
-        return '%02d:%02d:%02d' % (hours, mins, secs)
+        return "%02d:%02d:%02d" % (hours, mins, secs)
     else:
         days, hours = divmod(hours, 24)
-        return '%dd %02d:%02d:%02d' % (days, hours, mins, secs)
+        return "%dd %02d:%02d:%02d" % (days, hours, mins, secs)
+
 
 if __name__ == "__main__":
     opts = setup_options()
     if not opts.quiet:
-        print("Starting NandoD UDP:{0}:{1}, TCP:{0}:{2}".format(
+        print(
-           opts.HOST,
+            (
-           opts.PORT,
+                "Starting NandoD UDP:{0}:{1}, TCP:{0}:{2}".format(
-           opts.WEBPORT
+                    opts.HOST, opts.PORT, opts.WEBPORT
-        ))
+                )
-    UDP=threading.Thread(target=UDPserve)
+            )
-    UDP.daemon=True
+        )
+    UDP = UDPServe(opts)
     UDP.start()
     if opts.WEBPORT > 0:
-        TCP=threading.Thread(target=TCPserve)
+        TCP = TCPServe(opts)
-        TCP.daemon=True
         TCP.start()
     while True:
         try:
             time.sleep(1)
         except KeyboardInterrupt:
             print("Exiting..")
-            server.shutdown()
+            UDP.stop()
             if opts.WEBPORT > 0:
-                HTMLserver.shutdown()
+                TCP.stop()
             sys.exit(0)