runner

#! /usr/bin/python3

import os
import re
import sys
import glob
import subprocess
import logging

from optparse import OptionParser

re_ignore = re.compile(r'(~$|^_|\.(dpkg-(old|dist|new|tmp)|example)$|\.pyc|\.comc$)')

def main():
    parser = OptionParser("usage: %prog [options] start|stop|reload [configs]")

    parser.add_option('--pid-dir', dest='pid_dir',
        default='/var/run/gunicorn')
    parser.add_option('--log-dir', dest='log_dir',
        default='/var/log/gunicorn')
    parser.add_option('--server-name', dest='server_name',
        default='ksi-backend')

    parser.add_option('-v', '--verbosity', type='int', dest='verbosity',
        default=2, help='Verbosity level; 0=minimal output, 1=normal output' \
            ' 2=verbose output, 3=very verbose output')

    options, args = parser.parse_args()

    try:
        logging.basicConfig(
            format='%(levelname).1s: %(message)s',
            level={
                0: logging.ERROR,
                1: logging.WARNING,
                2: logging.INFO,
                3: logging.DEBUG,
            }[options.verbosity]
        )
    except KeyError:
        parser.error("Invalid verbosity level")

    log = logging.getLogger('gunicorn-debian')

    configs = args[1:]

    try:
        action = args[0]
    except IndexError:
        parser.error("Missing action")

    if action not in ('start', 'stop', 'restart', 'reload'):
        parser.error("Invalid action: %s" % action)

    if not os.path.exists(options.pid_dir):
        log.info("Creating %s", options.pid_dir)
        os.makedirs(options.pid_dir)

    sys.dont_write_bytecode = True

    CONFIG = {
        'working_dir': '.',
        'python': './ksi-py3-venv/bin/python3',
        'user': 'ksi',
        'group': 'ksi',
        'environment': {
           'PATH': os.environ[ "PATH" ],
        },
        'args': [
            '-c',
            'gunicorn_cfg.py',
            'app:api',
        ]
    }

    config = Config(options.server_name, options, CONFIG, log)

    log.debug("Calling .%s() on %s", action, config.basename())
    getattr(config, action)()

    return 0

class Config(dict):
    def __init__(self, filename, options, data, log):
        self.filename = filename
        self.options = options
        self.log = log

        data['args'] = list(data.get('args', []))
        data.setdefault('user', 'ksi')
        data.setdefault('group', 'ksi')
        data.setdefault('retry', '60')
        data.setdefault('environment', {})
        data.setdefault('working_dir', '.')
        data.setdefault('python', '/usr/bin/python3')

        self.update(data)

    def print_name(self):
        sys.stdout.write(" [%s]" % self.basename())
        sys.stdout.flush()

    def basename(self):
        return os.path.basename(self.filename)

    def pidfile(self):
        return os.path.join(self.options.pid_dir, '%s.pid' % self.basename())

    def logfile(self):
        return os.path.join(self.options.log_dir, '%s.log' % self.basename())

    def check_call(self, *args, **kwargs):
        self.log.debug("Calling subprocess.check_call(*%r, **%r)", args, kwargs)
        subprocess.check_call(*args, **kwargs)

    def start(self):
        daemon = './ksi-py3-venv/bin/gunicorn'

        args = [
            'start-stop-daemon',
            '--start',
            '--oknodo',
            '--quiet',
            '--chdir', self['working_dir'],
            '--pidfile', self.pidfile(),
            '--exec', self['python'], '--', daemon,
        ]

        gunicorn_args = [
            '--pid', self.pidfile(),
            '--name', self.basename(),
            '--user', self['user'],
            '--group', self['group'],
            '--daemon',
            '--log-file', self.logfile(),
        ]

        env = os.environ.copy()
        env.update(self['environment'])

        self.check_call(args + gunicorn_args + self['args'], env=env)

    def stop(self):
        self.check_call((
            'start-stop-daemon',
            '--stop',
            '--oknodo',
            '--quiet',
            '--retry', self['retry'],
            '--pidfile', self.pidfile(),
        ))

    def restart(self):
        self.stop()
        self.start()

    def reload(self):
        try:
            self.check_call((
                'start-stop-daemon',
                '--stop',
                '--signal', 'HUP',
                '--quiet',
                '--pidfile', self.pidfile(),
            ))
        except subprocess.CalledProcessError:
            self.log.debug("Could not reload, so restarting instead")
            self.restart()

if __name__ == '__main__':
    sys.exit(main())