import argparse

import sys

import runpy

import os

import os.path

import signal

import logging

import ginkgo

import ginkgo.util

from ginkgo.core import ContainerService, Service

STOP_SIGNAL = signal.SIGTERM

RELOAD_SIGNAL = signal.SIGHUP

def run_ginkgo():

parser = argparse.ArgumentParser(prog="ginkgo", add_help=False)

parser.add_argument("-v", "--version",

action="version", version="%(prog)s {}".format(ginkgo.__version__))

parser.add_argument("-h", "--help", action="store_true", help="""

show program's help text and exit

""".strip())

parser.add_argument("target", nargs='?', help="""

service class path to run (modulename.ServiceClass) or

configuration file path to use (/path/to/config.py)

""".strip())

args = parser.parse_args()

if args.help:

parser.print_help()

if args.target:

print # blank line

try:

app = prepare_app(args.target)

app.config.print_help()

except RuntimeError, e:

parser.error(e)

else:

if args.target:

try:

Runner().start(args.target)

except RuntimeError, e:

parser.error(e)

else:

parser.print_usage()

def run_ginkgoctl():

parser = argparse.ArgumentParser(prog="ginkgoctl")

parser.add_argument("-v", "--version",

action="version", version="%(prog)s {}".format(ginkgo.__version__))

parser.add_argument("-p", "--pid", help="""

pid or pidfile to use instead of target

""".strip())

parser.add_argument("target", nargs='?', help="""

service class path to use (modulename.ServiceClass) or

configuration file path to use (/path/to/config.py)

""".strip())

parser.add_argument("action",

choices=["start", "stop", "restart", "reload", "status"])

args = parser.parse_args()

if args.pid and args.target:

parser.error("You cannot specify both a target and a pid")

ginkgo.settings.set("daemon", True)

try:

if args.action in ["start", "restart"]:

if not args.target:

parser.error("You need to specify a target for {}".format(args.action))

getattr(Runner(), args.action)(args.target)

else:

getattr(Runner(), args.action)(resolve_pid(args.pid, args.target))

except RuntimeError, e:

parser.error(e)

def resolve_pid(pid=None, target=None):

if pid and not os.path.exists(pid):

return int(pid)

if target is not None:

prepare_app(target)

pid = ginkgo.settings.get("pidfile")

if pid is not None:

if os.path.exists(pid):

with open(pid, "r") as f:

pid = f.read().strip()

return int(pid)

else:

return

raise RuntimeError("Unable to resolve pid from {}".format(pid or target))

def load_class(class_path):

if '.' not in class_path:

raise RuntimeError("Invalid class path")

module_name, class_name = class_path.rsplit('.', 1)

try:

try:

module = runpy.run_module(module_name)

except ImportError:

module = runpy.run_module(module_name + ".__init__")

return module[class_name]

except (ImportError, KeyError), e:

raise RuntimeError("Unable to load class path: {}:\n{}".format(

class_path, e))

def prepare_app(target):

if os.path.exists(target):

config = ginkgo.settings.load_file(target)

try:

service = config['service']

except KeyError:

raise RuntimeError("Configuration does not specify a service")

else:

service = target

if isinstance(service, str):

service = load_class(service)()

elif callable(service):

# Class or factory

service = service()

else:

raise RuntimeError("Does not appear to be a valid service")

return Process(service)

class Runner(object):

def start(self, target):

print "Starting process with {}...".format(target)

app = prepare_app(target)

try:

app.serve_forever()

except KeyboardInterrupt:

pass

finally:

app.stop()

def restart(self, target):

self.stop(resolve_pid(target=target))

self.start(target)

def stop(self, pid):

if self._validate(pid):

print "Stopping process {}...".format(pid)

os.kill(pid, STOP_SIGNAL)

def reload(self, pid):

if self._validate(pid):

print "Reloading process {}...".format(pid)

os.kill(pid, RELOAD_SIGNAL)

def status(self, pid):

if self._validate(pid):

print "Process is running as {}.".format(pid)

def _validate(self, pid):

try:

os.kill(pid, 0)

return pid

except (OSError, TypeError):

print "Process is NOT running."

class Process(ContainerService):

daemon = ginkgo.Setting("daemon", default=False, help="""

True or False whether to daemonize

""".strip())

pidfile = ginkgo.Setting("pidfile", default=None, help="""

Path to pidfile to use when daemonizing

""".strip())

rundir = ginkgo.Setting("rundir", default=None, help="""

Change to a directory before running

""".strip())

user = ginkgo.Setting("user", default=None, help="""

Change to a different user before running

""".strip())

group = ginkgo.Setting("group", default=None, help="""

Change to a different group before running

""".strip())

umask = ginkgo.Setting("umask", default=None, help="""

Change file mode creation mask before running

""".strip())

def __init__(self, app_service, config=None):

self.config = config or ginkgo.settings

self.app = app_service

self.add_service(self.app)

if self.daemon:

if self.pidfile is None:

self.config.set("pidfile",

"/tmp/{}.pid".format(self.app.service_name))

self.pidfile = ginkgo.util.Pidfile(str(self.pidfile))

else:

self.pidfile = None

self.pid = os.getpid()

self.uid = os.geteuid()

self.gid = os.getegid()

self.environ = os.environ

ginkgo.process = ginkgo.process or self

def do_start(self):

ginkgo.util.prevent_core_dump()

if self.umask is not None:

os.umask(self.umask)

if self.rundir is not None:

os.chdir(self.rundir)

if self.user is not None:

pw_record = pwd.getpwnam(self.user)

self.uid = pw_record.pw_uid

self.gid = pw_record.pw_gid

os.setuid(self.uid)

os.setgid(self.gid)

if self.group is not None:

grp_record = grp.getgrnam(self.group)

self.gid = grp_record.gr_gid

os.setgid(gid)

if self.daemon:

ginkgo.util.daemonize()

self.pid = os.getpid()

self.pidfile.create(self.pid)

# TODO: placeholder for logs

f = open("/tmp/test.log", "w", buffering=0)

os.dup2(f.fileno(), sys.stderr.fileno())

os.dup2(f.fileno(), sys.stdout.fileno())

# TODO: move this to async manager?

import gevent

gevent.core.reinit()

# TODO: upgrade to gevent 1.0 and use standard signal

gevent.signal(RELOAD_SIGNAL, self.reload)

gevent.signal(STOP_SIGNAL, self.stop)

# TODO: use all those settings

def do_stop(self):

print "Stopping."

if self.daemon:

self.pidfile.unlink()

def trigger_hook(self, name, *args, **kwargs):

hook = self.config.get(name)

if hook is not None and callable(hook):

try:

hook(*args, **kwargs)

except Exception, e:

raise RuntimeWarning("Hook Error: {}".format(e))

def __enter__(self):

ginkgo.push_process(self)

return self

def __exit__(self, type, value, traceback):

ginkgo.pop_process()