Fix backup plugin

Update required Python version
Update pyln and other packages
Update README

backup/server.py

@@ -0,0 +1,129 @@
+import logging
+import socket
+import struct
+import json
+import sys
+from typing import Tuple
+
+from backend import Backend
+from protocol import PacketType, PKT_CHANGE_TYPES, change_from_packet, packet_from_change, send_packet, recv_packet
+
+
+class SystemdHandler(logging.Handler):
+    PREFIX = {
+        # EMERG <0>
+        # ALERT <1>
+        logging.CRITICAL: "<2>",
+        logging.ERROR: "<3>",
+        logging.WARNING: "<4>",
+        # NOTICE <5>
+        logging.INFO: "<6>",
+        logging.DEBUG: "<7>",
+        logging.NOTSET: "<7>"
+    }
+
+    def __init__(self, stream=sys.stdout):
+        self.stream = stream
+        logging.Handler.__init__(self)
+
+    def emit(self, record):
+        try:
+            msg = self.PREFIX[record.levelno] + self.format(record) + "\n"
+            self.stream.write(msg)
+            self.stream.flush()
+        except Exception:
+            self.handleError(record)
+
+
+def setup_server_logging(mode, level):
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level.upper())
+    mode = mode.lower()
+    if mode == 'systemd':
+        # replace handler with systemd one
+        root_logger.handlers = []
+        root_logger.addHandler(SystemdHandler())
+    else:
+        assert mode == 'plain'
+
+
+class SocketServer:
+    def __init__(self, addr: Tuple[str, int], backend: Backend) -> None:
+        self.backend = backend
+        self.addr = addr
+        self.bind = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.bind.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.bind.bind(addr)
+
+    def _send_packet(self, typ: int, payload: bytes) -> None:
+        send_packet(self.sock, typ, payload)
+
+    def _recv_packet(self) -> Tuple[int, bytes]:
+        return recv_packet(self.sock)
+
+    def _handle_conn(self, conn) -> None:
+        # Can only handle one connection at a time
+        logging.info('Servicing incoming connection')
+        self.sock = conn
+        while True:
+            try:
+                (typ, payload) = self._recv_packet()
+            except IOError:
+                logging.info('Connection closed')
+                break
+            if typ in PKT_CHANGE_TYPES:
+                change = change_from_packet(typ, payload)
+                if typ == PacketType.CHANGE:
+                    logging.debug('Received CHANGE {}'.format(change.version))
+                else:
+                    logging.info('Received SNAPSHOT {}'.format(change.version))
+                self.backend.add_change(change)
+                self._send_packet(PacketType.ACK, struct.pack("!I", self.backend.version))
+            elif typ == PacketType.REWIND:
+                logging.info('Received REWIND')
+                to_version, = struct.unpack('!I', payload)
+                if to_version != self.backend.prev_version:
+                    logging.info('Cannot rewind to version {}'.format(to_version))
+                    self._send_packet(PacketType.NACK, struct.pack("!I", self.backend.version))
+                else:
+                    self.backend.rewind()
+                    self._send_packet(PacketType.ACK, struct.pack("!I", self.backend.version))
+            elif typ == PacketType.REQ_METADATA:
+                logging.debug('Received REQ_METADATA')
+                blob = struct.pack("!IIIQ", 0x01, self.backend.version,
+                                   self.backend.prev_version,
+                                   self.backend.version_count)
+                self._send_packet(PacketType.METADATA, blob)
+            elif typ == PacketType.RESTORE:
+                logging.info('Received RESTORE')
+                for change in self.backend.stream_changes():
+                    (typ, payload) = packet_from_change(change)
+                    self._send_packet(typ, payload)
+                self._send_packet(PacketType.DONE, b'')
+            elif typ == PacketType.COMPACT:
+                logging.info('Received COMPACT')
+                stats = self.backend.compact()
+                self._send_packet(PacketType.COMPACT_RES, json.dumps(stats).encode())
+            elif typ == PacketType.ACK:
+                logging.debug('Received ACK')
+            elif typ == PacketType.NACK:
+                logging.debug('Received NACK')
+            elif typ == PacketType.METADATA:
+                logging.debug('Received METADATA')
+            elif typ == PacketType.COMPACT_RES:
+                logging.debug('Received COMPACT_RES')
+            else:
+                raise Exception('Unknown or unexpected packet type {}'.format(typ))
+        self.conn = None
+
+    def run(self) -> None:
+        self.bind.listen(1)
+        logging.info('Waiting for connection on {}'.format(self.addr))
+        while True:
+            conn, _ = self.bind.accept()
+            try:
+                self._handle_conn(conn)
+            except Exception:
+                logging.exception('Got exception')
+            finally:
+                conn.close()