pichator-daemon

#!/usr/bin/python3 -tt
# -*- coding: utf-8 -*-

# Twisted hosts our website and helps with async tasks.
# The application threads are structured in the following way:
#
#  reactor
#   `-- manager (1 thread)
#   `-- workers (2 threads)
#   `-- website (4 threads)
#

from twisted.internet import reactor
from twisted.web.wsgi import WSGIResource
from twisted.web.server import Site
from twisted.python.threadpool import ThreadPool
from twisted.python import log

from getopt import gnu_getopt
from sys import argv, stderr

from pichator import Manager, make_site, Ekv, AccessModel, Elanor

from datetime import datetime

# Data are accessed through SQLSoup, using SQLAlchemy.
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy import create_engine
from sqlsoup import SQLSoup

from configparser import ConfigParser

import os
# Uncomment to use Czech language with oracle database
# os.environ["NLS_LANG"] = "CZECH_CZECH REPUBLIC.AL32UTF8"

if __name__ == '__main__':
    def do_start(config):
        # Start Twisted logging to console.
        log.startLogging(stderr)

        # Read database iniuration options.
        pg_url = config.get('postgres', 'url')
        ekv_url = config.get('ekv','url')
        elanor_url = config.get('elanor', 'url')

        # Read website configuration options.
        http_debug = config.getboolean('http', 'debug', fallback=False)
        http_host = config.get('http', 'host', fallback='localhost')
        http_port = config.getint('http', 'port', fallback=5000)
        http_pool = config.getint('http', 'pool_size', fallback=4)
        
        # Read role mappings.
        access_model = AccessModel(config.items('access'))

        # Extract manager options, sans the pool_size we handle here.
        manager_opts = dict(config.items('manager'))
        manager_pool = int(manager_opts.pop('pool_size', 2))

        # Set the correct thread pool size for the manager.
        reactor.suggestThreadPoolSize(manager_pool)

        # Prepare database connection with table reflection.
        #pg_engine = create_engine(pg_url, isolation_level='SERIALIZABLE')
        #pg_session = scoped_session(sessionmaker(
        #    autocommit=False, autoflush=False))
        #pg_db = SQLSoup(pg_engine, session=pg_session)
        pg_db = SQLSoup(pg_url)
        
        #ekv_engine = create_engine(ekv_url, isolation_level='SERIALIZABLE')
        #ekv_session = scoped_session(sessionmaker(
        #    autocommit=False, autoflush=False))
        #ekv_db = SQLSoup(ekv_engine, session=ekv_session)
        ekv_db = SQLSoup(ekv_url)
        
        #elanor_engine = create_engine(elanor_url)
        #elanor_session = scoped_session(sessionmaker(
        #    autocommit=False, autoflush=False))
        #elanor_db = SQLSoup(elanor_engine, session=elanor_session)
        elanor_db = SQLSoup(elanor_url)


        # Prepare the manager that runs in an exclusive thread.
        manager = Manager(pg_db)
        ekv = Ekv(ekv_db)
        elanor = Elanor(elanor_db)

        # Prepare the website that will get exposed to the users.
        site = make_site(manager, access_model, debug=http_debug)

        # Prepare WSGI site with a separate thread pool.
        pool = ThreadPool(http_pool, http_pool, 'http')
        site = Site(WSGIResource(reactor, pool, site))
        pool.start()

        # Init presence at first run
        # !!WARING!! Can take very long time
        '''
        year = datetime.now().date().year
        for i in range(1, 13):
            manager.init_presence(year=year, month=i, source=ekv)
        '''
        # Bind the website to it's address.
        reactor.listenTCP(http_port, site, interface=http_host)
        
        # Schedule to call manager sync from ekv
        reactor.callLater(0,manager.sync, source=ekv, source_name='ekv', elanor=elanor)
        
        # Run the Twisted reactor until the user terminates us.
        reactor.run()

        # Kill the HTTP ThreadPool.
        pool.stop()

    def do_help(*args, **kwargs):
        print('Usage: pichator-daemon [--config=config/pichator-prod.ini]')
        print('Runs the pichator-daemon with given configuration.')
        print('')
        print('OPTIONS:')
        print('  --help, -h          Display this help.')
        print('  --version, -V       Display version info.')
        print('')
        print('  --config, -c file   Load alternative configuration file.')
        print('')
        print('Report bugs at <http://github.com/techlib/pichator>.')

    def do_version(*args, **kwargs):
        print('pichator (NTK) 1')

    # Parse command line arguments.
    opts, args = gnu_getopt(argv, 'hVc:', ['help', 'version', 'config='])

    action = do_start
    config_path = 'config/pichator-prod.ini'

    for k, v in opts:
        if k in ('--help', '-h'):
            action = do_help
        elif k in ('--version', '-V'):
            action = do_version
        elif k in ('--config', '-c'):
            config_path = v

    # Load the configuration from file.
    if action not in (do_help, do_version):
        config = ConfigParser()
        config.read(config_path)

    # Load the configuration from file.
    config = ConfigParser()
    config.read(config_path)

    # Perform the selected action.
    action(config=config)

# vim:set sw=4 ts=4 et:
# -*- coding: utf-8 -*-