Update application code for Heroku + SQLAlchemy

Updated to accomodate new logging configuration (stdout),
command line options, and to be able to provide sqlalchemy
sessions for database calls.

app/app.py

@@ -1,14 +1,17 @@
import contextlib
import json
import logging
import os

import jsonschema
import sqlalchemy as sa
import tornado.ioloop
import tornado.log
import tornado.options
import tornado.web

from ipythonblocks import BlockGrid
from sqlalchemy.orm import sessionmaker
from twiggy import log

# local imports
@@ -17,19 +20,13 @@
from .colorize import colorize
from .twiggy_setup import twiggy_setup

tornado.options.define('tornado_log_file',
                       default='/var/log/ipborg/tornado.log',
                       type=str)
tornado.options.define('app_log_file',
                       default='/var/log/ipborg/app.log',
                       type=str)
tornado.options.parse_command_line()
tornado.options.define('port', default=80, type=int)
tornado.options.define('db_url', type=str)
log = log.name(__name__)


def configure_tornado_logging():
    fh = logging.handlers.RotatingFileHandler(
        tornado.options.options.tornado_log_file,
        maxBytes=2**29, backupCount=10)
    fh = logging.StreamHandler()

    fmt = logging.Formatter('%(asctime)s:%(levelname)s:%(name)s:%(message)s')
    fh.setFormatter(fmt)
@@ -41,14 +38,6 @@ def configure_tornado_logging():
    tornado.log.enable_pretty_logging(logger=logger)


settings = {
    'static_path': os.path.join(os.path.dirname(__file__), 'static'),
    'template_path': os.path.join(os.path.dirname(__file__), 'templates'),
    'debug': True,
    'gzip': True
}


class MainHandler(tornado.web.StaticFileHandler):
    def parse_url_path(self, url_path):
        return 'main.html'
@@ -59,7 +48,21 @@ def parse_url_path(self, url_path):
        return 'about.html'


class PostHandler(tornado.web.RequestHandler):
class DBAccessHandler(tornado.web.RequestHandler):
    @contextlib.contextmanager
    def session_context(self):
        session = self.application.session_factory()
        try:
            yield session
            session.commit()
        except:
            session.rollback()
            raise
        finally:
            session.close()


class PostHandler(DBAccessHandler):
    def post(self):
        try:
            req_data = json.loads(self.request.body)
@@ -73,7 +76,8 @@ def post(self):
            log.debug('Post JSON validation failed.')
            raise tornado.web.HTTPError(400, 'Post JSON validation failed.')

        hash_id = dbi.store_grid_entry(req_data)
        with self.session_context() as session:
            hash_id = dbi.store_grid_entry(session, req_data)

        if req_data['secret']:
            url = 'http://ipythonblocks.org/secret/{}'
@@ -85,33 +89,37 @@ def post(self):
        self.write({'url': url})


class GetGridSpecHandler(tornado.web.RequestHandler):
class GetGridSpecHandler(DBAccessHandler):
    def initialize(self, secret):
        self.secret = secret

    def get(self, hash_id):
        grid_spec = dbi.get_grid_entry(hash_id, self.secret)
        if not grid_spec:
            raise tornado.web.HTTPError(404, 'Grid not found.')
        with self.session_context() as session:
            grid_spec = dbi.get_grid_entry(session, hash_id, self.secret)

            if not grid_spec:
                raise tornado.web.HTTPError(404, 'Grid not found.')

        self.write(grid_spec['grid_data'])
            self.write(grid_spec.grid_data)


class RandomHandler(tornado.web.RequestHandler):
class RandomHandler(DBAccessHandler):
    def get(self):
        hash_id = dbi.get_random_hash_id()
        with self.session_context() as session:
            hash_id = dbi.get_random_hash_id(session)
        log.info('redirecting to url /{0}', hash_id)
        self.redirect('/' + hash_id, status=303)


class ErrorHandler(tornado.web.RequestHandler):
class ErrorHandler(DBAccessHandler):
    def get(self):
        self.send_error(404)

    def write_error(self, status_code, **kwargs):
        if status_code == 404:
            self.render('404.html')
        else:
            super(ErrorHandler, self).send_error(status_code, **kwargs)
            super().send_error(status_code, **kwargs)


class RenderGridHandler(ErrorHandler):
@@ -120,38 +128,59 @@ def initialize(self, secret):

    @tornado.web.removeslash
    def get(self, hash_id):
        grid_spec = dbi.get_grid_entry(hash_id, secret=self.secret)
        if not grid_spec:
            self.send_error(404)
            return
        with self.session_context() as session:
            grid_spec = dbi.get_grid_entry(session, hash_id, secret=self.secret)

        gd = grid_spec['grid_data']
        grid = BlockGrid(gd['width'], gd['height'], lines_on=gd['lines_on'])
        grid._load_simple_grid(gd['blocks'])
        grid_html = grid._repr_html_()
            if not grid_spec:
                self.send_error(404)
                return

        code_cells = grid_spec['code_cells'] or []
        code_cells = [colorize(c) for c in code_cells]
            gd = grid_spec.grid_data
            grid = BlockGrid(gd['width'], gd['height'], lines_on=gd['lines_on'])
            grid._load_simple_grid(gd['blocks'])
            grid_html = grid._repr_html_()

        self.render('grid.html', grid_html=grid_html, code_cells=code_cells)
            code_cells = grid_spec.code_cells or []
            code_cells = [colorize(c) for c in code_cells]

            self.render('grid.html', grid_html=grid_html, code_cells=code_cells)


class AppWithSession(tornado.web.Application):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.engine = sa.create_engine(tornado.options.options.db_url)
        self.session_factory = sessionmaker(bind=self.engine)


SETTINGS = {
    'static_path': os.path.join(os.path.dirname(__file__), 'static'),
    'template_path': os.path.join(os.path.dirname(__file__), 'templates'),
    'debug': True,
    'gzip': True
}


application = tornado.web.Application([
    (r'/()', MainHandler, {'path': settings['template_path']}),
    (r'/(about)', AboutHandler, {'path': settings['template_path']}),
    (r'/random', RandomHandler),
    (r'/post', PostHandler),
    (r'/get/(\w{6}\w*)', GetGridSpecHandler, {'secret': False}),
    (r'/get/secret/(\w{6}\w*)', GetGridSpecHandler, {'secret': True}),
    (r'/(\w{6}\w*)/*', RenderGridHandler, {'secret': False}),
    (r'/secret/(\w{6}\w*)/*', RenderGridHandler, {'secret': True}),
    (r'/.*', ErrorHandler)
], **settings)
def make_application():
    return AppWithSession(handlers=[
        (r'/()', MainHandler, {'path': SETTINGS['template_path']}),
        (r'/(about)', AboutHandler, {'path': SETTINGS['template_path']}),
        (r'/random', RandomHandler),
        (r'/post', PostHandler),
        (r'/get/(\w{6}\w*)', GetGridSpecHandler, {'secret': False}),
        (r'/get/secret/(\w{6}\w*)', GetGridSpecHandler, {'secret': True}),
        (r'/(\w{6}\w*)/*', RenderGridHandler, {'secret': False}),
        (r'/secret/(\w{6}\w*)/*', RenderGridHandler, {'secret': True}),
        (r'/.*', ErrorHandler)
    ], **SETTINGS)


if __name__ == '__main__':
    tornado.options.parse_command_line()
    configure_tornado_logging()
    twiggy_setup()

    application.listen(8877)
    log.fields(port=tornado.options.options.port).info('starting server')
    application = make_application()
    application.listen(tornado.options.options.port)
    tornado.ioloop.IOLoop.instance().start()

app/test/test_app.py

@@ -2,32 +2,31 @@
import os
import tempfile

import dataset
import pytest
import sqlalchemy as sa
import testing.postgresql
import tornado.options
import tornado.testing

import mock
from sqlalchemy.orm import sessionmaker

from .. import app
from .. import dbinterface as dbi
from .. import models


def setup_module(module):
    tornado.options.options.public_salt = 'public'
    tornado.options.options.secret_salt = 'secret'
    dbi.get_memcached().flush_all()
    module.PG_FACTORY = testing.postgresql.PostgresqlFactory(
        cache_initialized_db=True)


def teardown_module(module):
    dbi.get_memcached().flush_all()


def setup_function(function):
    _, tornado.options.options.db_file = tempfile.mkstemp()
    module.PG_FACTORY.clear_cache()


def teardown_function(function):
    os.remove(tornado.options.options.db_file)
@pytest.fixture(autouse=True)
def set_salts(monkeypatch):
    monkeypatch.setenv('HASHIDS_PUBLIC_SALT', 'public')
    monkeypatch.setenv('HASHIDS_SECRET_SALT', 'secret')


def data_2x2():
@@ -53,24 +52,30 @@ def request():

class UtilBase(tornado.testing.AsyncHTTPTestCase):
    def setup_method(self, method):
        _, tornado.options.options.db_file = tempfile.mkstemp()
        self.postgresql = PG_FACTORY()
        self.engine = sa.create_engine(self.postgresql.url())
        models.Base.metadata.create_all(bind=self.engine)
        self.Session = sessionmaker(bind=self.engine)
        self.session = self.Session()
        tornado.options.options.db_url = self.postgresql.url()

    def teardown_method(self, method):
        os.remove(tornado.options.options.db_file)
        self.session.close()
        self.Session.close_all()
        self.engine.dispose()
        self.postgresql.stop()

    def get_app(self):
        return app.application
        return app.make_application()

    def get_response(self, body=None):
        self.http_client.fetch(
            self.get_url(self.app_url), self.stop,
            method=self.method, body=body)
        return self.wait()
        return self.fetch(self.app_url, method=self.method, body=body)

    def save_grid(self, secret):
        req = request()
        req['secret'] = secret
        hash_id = dbi.store_grid_entry(req)
        hash_id = dbi.store_grid_entry(self.session, req)
        self.session.commit()
        return hash_id


@@ -115,9 +120,13 @@ def test_stores_data(self):

        body = json.loads(response.body)
        hash_id = body['url'].split('/')[-1]
        grid_spec = dbi.get_grid_entry(hash_id)
        del grid_spec['id']
        assert grid_spec == json.loads(json.dumps(req))
        grid_spec = dbi.get_grid_entry(self.session, hash_id)
        assert grid_spec.id == 1

        comp_data= json.loads(json.dumps(req))

        for key, value in comp_data.items():
            assert getattr(grid_spec, key) == value


class TestGetGrid(UtilBase):
@@ -175,14 +184,14 @@ def test_render(self):

        response = self.get_response()
        assert response.code == 200
        assert '<table' in response.body
        assert 'asdf' in response.body
        assert b'<table' in response.body
        assert b'asdf' in response.body

    def test_render_secret(self):
        hash_id = self.save_grid(True)
        self.app_url = '/secret/{}'.format(hash_id)

        response = self.get_response()
        assert response.code == 200
        assert '<table' in response.body
        assert 'asdf' in response.body
        assert b'<table' in response.body
        assert b'asdf' in response.body