HTTP api

.gitignore

@@ -1,3 +1,4 @@
 *.py[co]
 __pycache__/
 venv/
+config.py

README.md

@@ -15,5 +15,18 @@ Setup
    - fish: `. venv/bin/activate.fish`
    - csh, tcsh: `source venv/bin/activate.csh`
 3. Install dependencies if necessary: `pip install -r requirements.txt`
+4. configure: `cp config.py{.example,}; $EDITOR config.py`
+5. bootstrap (create DB tables and such): `./bootstrap.py`
+6. run with `./run.py` (or `while true; do sleep 0.1; ./run.py; done`, as the
+   server will stop when the code changes => auto-restart on save ^_^)
 
 The rest doesn't exist yet.
+
+Next to do:
+-----------
+
+- tests
+- listen on UDP socket
+- wrap/unwrap NaCl
+- fix DB singleton (who wants a singleton?!) -- inversion of control
+- CI

bootstrap.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+
+import config
+from gateserver import db
+
+def db_create_tables():
+    print('Creating DB tables...', end='')
+    with open('./tables.sql', 'r') as f:
+        if not db.conn: db.connect(config.db_url)
+        for line in f:
+            line = line.split('#')[0].strip()
+            if line: db.exec_sql('CREATE TABLE IF NOT EXISTS ' + line)
+    print(' OK')
+
+def all():
+    db_create_tables()
+
+if __name__ == '__main__':
+    all()

config.py.example

@@ -0,0 +1,11 @@
+"""The server configuration."""
+
+http_api = {
+    'port': 5047,
+}
+
+controller_api = {
+    'port': 5042,
+}
+
+db_url = 'postgresql://user:password@host/dbname'

gateserver/controller_api.py

@@ -0,0 +1,5 @@
+"""The UDP server that provides the API for the controllers."""
+
+def serve(config):
+    # TODO
+    print('controller_api would start serving')

gateserver/db.py

@@ -0,0 +1,21 @@
+"""Holds the (global) connection to the DB."""
+# TODO maybe use a connection pool one beautiful day
+
+import config
+import psycopg2
+
+conn = None
+
+def connect(db_url):
+    global conn
+    conn = psycopg2.connect(db_url)
+    conn.autocommit=True
+
+def exec_sql(query, args=(), ret=False):
+    """Execute the query, returning the result as a list if `ret` is set."""
+    with conn.cursor() as cur:
+        cur.execute(query, args)
+        if ret: return cur.fetchall()
+
+# thrown when constraints aren't satisfied
+IntegrityError = psycopg2.IntegrityError

gateserver/http_api.py

@@ -0,0 +1,81 @@
+"""Defines the REST API for CRUD and management."""
+
+from . import db
+import nacl.raw as nacl
+import cherrypy
+
+class MountPoint:
+    """Represents a mount point, or path prefix, for attaching resources to."""
+    pass
+
+class Resource(MountPoint):
+    """Represents a REST resource."""
+    exposed = True
+
+class CRUDResource(Resource):
+    """Represents a REST resource that exposes a DB table's CRUD methods."""
+    def __init__(self, tbl, put_columns, get_columns, on_save=lambda x: x):
+        assert(tbl.isidentifier())
+        self.table       = tbl
+        self.put_columns = put_columns
+        self.get_columns = get_columns
+        self.on_save     = on_save
+
+    @cherrypy.tools.json_out()
+    def GET(self, id=None):
+        cols = list(self.get_columns)
+        q = 'SELECT {} FROM {}'.format(','.join(cols), self.table)
+        if id: q += ' WHERE id = %s'
+        rs = [ dict(zip(cols, r)) for r in db.exec_sql(q, (id,), ret=True) ]
+        if id:
+            if len(rs) < 1: raise cherrypy.HTTPError('404 Not Found')
+            return rs[0]
+        else: return rs
+
+    @cherrypy.tools.json_in()
+    @cherrypy.tools.json_out()
+    def PUT(self, id):
+        json = self.on_save(dict(cherrypy.request.json, id=id))
+        print(json)
+        cols, values, ps = [], [], []
+        for c in self.put_columns:
+            cols.append(c)
+            values.append(json.get(c))
+            ps.append('%s')
+        q = 'INSERT INTO controller ({}) VALUES ({})'.format(','.join(cols),
+                                                             ','.join(ps))
+        try:
+            db.exec_sql(q, values)
+        except db.IntegrityError as e:
+            raise cherrypy.HTTPError('400 Bad Request', e.pgerror)
+        return { 'url': cherrypy.url() }
+
+    # TODO POST
+
+    def DELETE(self, id):
+        db.exec_sql('DELETE FROM {} WHERE id = %s'.format(self.table), (id,))
+
+################################################################################
+
+api_root = MountPoint()
+api_root.controller = CRUDResource('controller',
+        get_columns={'id', 'ip', 'name'},
+        put_columns={'id', 'ip', 'key', 'name'},
+        on_save=lambda ctrl:
+            dict(ctrl, key=nacl.randombytes(nacl.crypto_secretbox_KEYBYTES)))
+
+################################################################################
+
+cherrypy_conf = {
+    '/': {
+        'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
+    }
+}
+cherrypy.tree.mount(api_root, '/', cherrypy_conf)
+
+def serve(config):
+    cherrypy.config.update({'server.socket_port': config['port']})
+    cherrypy.engine.start()
+
+def stop():
+    cherrypy.engine.exit()

requirements.txt

@@ -1,2 +1,3 @@
+CherryPy==3.6.0
 psycopg2==2.5.4
 https://github.com/warner/python-tweetnacl/tarball/b48a25a33f

run.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Gate server runner."""
+
+from gateserver import db, controller_api, http_api
+import config
+
+def serve():
+    db.connect(config.db_url)
+    controller_api.serve(config.controller_api)
+    http_api.serve(config.http_api)
+
+if __name__ == '__main__':
+    serve()

tables.sql

@@ -0,0 +1 @@
+controller (id macaddr PRIMARY KEY, ip inet UNIQUE NOT NULL, key bytea NOT NULL, name text)