Server DB implemented

Signed-off-by: Jonas Kalderstam <[email protected]>

Author: spacecowboy

server-app/.gitignore

@@ -1 +1,2 @@
 *.pyc
+*.db

server-app/app.py

@@ -1,33 +1,81 @@
-import bottle
-from bottle import run, get, post, delete
+from hashlib import sha1
+from bottle import run, get, post, delete, install, HTTPError, request
+from bottle_sqlite import SQLitePlugin
+
+from dbsetup import init_db
+
+
+DBNAME='test.db'
+
+init_db(DBNAME)
+install(SQLitePlugin(dbfile=DBNAME))
+
+def to_dict(row):
+    return dict(sha=row['sha'],
+                url=row['url'],
+                timestamp=row['timestamp'],
+                # Convert integer to boolean
+                deleted=(1 == row['deleted']))
+
 
 @get('/')
 @get('/links')
-def list_links():
+def list_links(db):
     '''Return a complete list of all links'''
-    return dict(links=[])
+    links = []
+    for row in db.execute('SELECT * from links'):
+        links.append(to_dict(row))
+    return dict(links=links)
 
-@get('/links/<id>')
-def get_link(id):
+@get('/links/<sha>')
+def get_link(db, sha):
     '''Returns a specific link'''
-    return dict(link={"sha":"1111111",
-                      "url":"http://www.google.com",
-                      "timestamp":"2013-09-19 08:22:19.000"})
+    row = db.execute('SELECT * from links WHERE sha IS ?', [sha]).fetchone()
+    if row:
+        return dict(link=to_dict(row))
+
+    return HTTPError(404, "No such item")
 
-@delete('/links/<id>')
-def delete_link(id):
+@delete('/links/<sha>')
+def delete_link(db, sha):
     '''Deletes a specific link from the list.
     On success, returns an empty response'''
-    return {}
+    db.execute('UPDATE links SET deleted = 1, timestamp = CURRENT_TIMESTAMP \
+    WHERE sha IS ? AND userid is ?', [sha, userid])
+
+    if db.total_changes > 0:
+        return {}
+
+    return HTTPError(404, "No such item")
 
 @post('/links')
-def add_link():
+def add_link(db):
     '''Adds a link to the list.
     On success, returns the entry created.'''
-    return dict(link={"sha":"1111111",
-                      "url":"http://www.google.com",
-                      "timestamp":"2013-09-19 08:22:19.000"})
+    # Only accept json data
+    if request.content_type != 'application/json':
+        return HTTPError(415, "Only json is accepted")
+    # Check required fields
+    if 'url' not in request.json:
+        return HTTPError(400, "Must specify a url")
+
+    # Sha is optional, generate if not present
+    if 'sha' not in request.json:
+        request.json['sha'] = sha1(request.json['url']).hexdigest()
+
+    args = [request.json['url'],
+            request.json['sha']]
+    if 'timestamp' in request.json:
+        args.append(request.json['timestamp'])
+        stmt = 'INSERT INTO links (url, sha, timestamp) VALUES(?, ?, ?)'
+    else:
+        stmt = 'INSERT INTO links (url, sha) VALUES(?, ?)'
+
+    db.execute(stmt, args)
+
+    return get_link(db, request.json['sha'])
+
 
 if __name__ == '__main__':
-    bottle.debug(True)
-    run(port=5500)
+    # Restart server automatically when this file changes
+    run(host='0.0.0.0', port=5500, reloader=True, debug=True)

server-app/bottle_sqlite.py

@@ -0,0 +1,104 @@
+'''
+Bottle-sqlite is a plugin that integrates SQLite3 with your Bottle
+application. It automatically connects to a database at the beginning of a
+request, passes the database handle to the route callback and closes the
+connection afterwards.
+
+To automatically detect routes that need a database connection, the plugin
+searches for route callbacks that require a `db` keyword argument
+(configurable) and skips routes that do not. This removes any overhead for
+routes that don't need a database connection.
+
+Usage Example::
+
+    import bottle
+    from bottle.ext import sqlite
+
+    app = bottle.Bottle()
+    plugin = sqlite.Plugin(dbfile='/tmp/test.db')
+    app.install(plugin)
+
+    @app.route('/show/:item')
+    def show(item, db):
+        row = db.execute('SELECT * from items where name=?', item).fetchone()
+        if row:
+            return template('showitem', page=row)
+        return HTTPError(404, "Page not found")
+'''
+
+__author__ = "Marcel Hellkamp"
+__version__ = '0.1.2'
+__license__ = 'MIT'
+
+### CUT HERE (see setup.py)
+
+import sqlite3
+import inspect
+from bottle import HTTPResponse, HTTPError
+
+
+class SQLitePlugin(object):
+    ''' This plugin passes an sqlite3 database handle to route callbacks
+    that accept a `db` keyword argument. If a callback does not expect
+    such a parameter, no connection is made. You can override the database
+    settings on a per-route basis. '''
+
+    name = 'sqlite'
+
+    def __init__(self, dbfile=':memory:', autocommit=True, dictrows=True,
+                 keyword='db'):
+         self.dbfile = dbfile
+         self.autocommit = autocommit
+         self.dictrows = dictrows
+         self.keyword = keyword
+
+    def setup(self, app):
+        ''' Make sure that other installed plugins don't affect the same
+            keyword argument.'''
+        for other in app.plugins:
+            if not isinstance(other, SQLitePlugin): continue
+            if other.keyword == self.keyword:
+                raise PluginError("Found another sqlite plugin with "\
+                "conflicting settings (non-unique keyword).")
+
+    def apply(self, callback, context):
+        # Override global configuration with route-specific values.
+        conf = context['config'].get('sqlite') or {}
+        dbfile = conf.get('dbfile', self.dbfile)
+        autocommit = conf.get('autocommit', self.autocommit)
+        dictrows = conf.get('dictrows', self.dictrows)
+        keyword = conf.get('keyword', self.keyword)
+
+        # Test if the original callback accepts a 'db' keyword.
+        # Ignore it if it does not need a database handle.
+        args = inspect.getargspec(context['callback'])[0]
+        if keyword not in args:
+            return callback
+
+        def wrapper(*args, **kwargs):
+            # Connect to the database
+            db = sqlite3.connect(dbfile)
+            # This enables column access by name: row['column_name']
+            if dictrows: db.row_factory = sqlite3.Row
+            # Add the connection handle as a keyword argument.
+            kwargs[keyword] = db
+
+            try:
+                rv = callback(*args, **kwargs)
+                if autocommit: db.commit()
+            except sqlite3.IntegrityError, e:
+                db.rollback()
+                raise HTTPError(500, "Database Error", e)
+            except HTTPError, e:
+                raise
+            except HTTPResponse, e:
+                if autocommit: db.commit()
+                raise
+            finally:
+                db.close()
+            return rv
+
+        # Replace the route callback with the wrapped one.
+        return wrapper
+
+Plugin = SQLitePlugin

server-app/curl_tests.sh

@@ -10,4 +10,11 @@ echo "\n\nGetting one"
 curl -X GET http://localhost:5500/links/42
 
 echo "\n\nAdding one"
-curl -X POST http://localhost:5500/links
+curl -X POST -H "Content-Type: application/json" -d '{"url":"http://www.google.com","username":"xyz","password":"xyz"}' http://localhost:5500/links
+
+echo "\n\nAdding wrong header"
+curl -X POST -d '{"username":"xyz","password":"xyz"}' http://localhost:5500/links
+
+
+echo "\n\nAdding no url"
+curl -X POST -H "Content-Type: application/json" -d '{"username":"xyz","password":"xyz"}' http://localhost:5500/links

server-app/dbsetup.py

@@ -0,0 +1,28 @@
+import sqlite3 as sql
+import sys
+
+_CREATE_TABLE = \
+"""CREATE TABLE IF NOT EXISTS links
+  (_id INTEGER PRIMARY KEY,
+  userid TEXT NOT NULL,
+  sha TEXT NOT NULL,
+  url TEXT NOT NULL,
+  deleted INTEGER NOT NULL DEFAULT 0,
+  timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+  UNIQUE(userid, url) ON CONFLICT REPLACE,
+  UNIQUE(userid, sha) ON CONFLICT REPLACE)
+"""
+
+def init_db(filename='test.db'):
+    con = sql.connect(filename)
+    con.row_factory = sql.Row
+    with con:
+        cur = con.cursor()
+        cur.execute(_CREATE_TABLE)
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        init_db(sys.argv[1])
+    else:
+        init_db()