Пример #1
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-d', '--db', type = str, help = 'SQLite3 DB to write to')
    parser.add_argument('-z', '--zmq', type = str, help = 'ZMQ to listen for', required = True)
    parser.add_argument('-L', '--log', type = str, help = 'Log file (will cause it to daemonise)')
    parser.add_argument('-P', '--pidfile', type = str, help = 'PID file (only used with --log)')
    args = parser.parse_args()

    if args.db != None:
        db = sqlite3.connect(args.db)
        c = db.cursor()
        c.execute('CREATE VIRTUAL TABLE IF NOT EXISTS pages_fts USING fts4(pid, msg);')
        c.execute('''
CREATE TABLE IF NOT EXISTS pages(
    id     INTEGER PRIMARY KEY AUTOINCREMENT,
    type    TEXT,
    chfreq  REAL,
    captime INTEGER,
    msg     TEXT
);
''')
        c.execute('CREATE INDEX IF NOT EXISTS pages_id ON pages(id)')
        c.execute('CREATE INDEX IF NOT EXISTS pages_captime ON pages(captime)')
        c.execute('''
CREATE TABLE IF NOT EXISTS pocsag_pages(
    pid     INTEGER,
    rate    INTEGER,
    address INTEGER,
    func    INTEGER,
    ptype   TEXT,

    FOREIGN KEY(pid) REFERENCES pages(id)
);
''')
        c.execute('CREATE INDEX IF NOT EXISTS pocsag_pages_id ON pocsag_pages(pid)')
        c.execute('''
CREATE TABLE IF NOT EXISTS flex_pages(
    pid     INTEGER,
    msgtime INTEGER,
    baud    INTEGER,
    level   INTEGER,
    phaseno CHAR(1),
    cycleno INTEGER,
    frameno INTEGER,
    capcode INTEGER,

    FOREIGN KEY(pid) REFERENCES pages(id)
);
''')
        c.execute('CREATE INDEX IF NOT EXISTS flex_pages_id ON flex_pages(pid)')
        c.execute('''
CREATE TABLE IF NOT EXISTS frequencies (
    freq    REAL,
    name    TEXT UNIQUE
);
''')

    # Configure logging
    global logger
    logger = logging.getLogger('zmqlog')
    logger.setLevel(logging.DEBUG)

    if args.log != None:
        lh = logging.handlers.WatchedFileHandler(args.log)
    else:
        lh = logging.StreamHandler()

    lh.setFormatter(logging.Formatter('%(asctime)s %(name)s:%(levelname)s: %(message)s', '%Y/%m/%d %H:%M:%S'))
    logger.addHandler(lh)

    daemon_context = daemon.DaemonContext()
    daemon_context.files_preserve = [lh.stream]

    # Daemonise if we have a log file
    if args.log != None:
        pidfile = None
        if args.pidfile != None:
            pidfile = daemon.pidfile.PIDLockFile(args.pidfile)

        ctxmgr = daemon.DaemonContext(pidfile = pidfile, files_preserve = [lh.stream])
    else:
        ctxmgr = NullContextManager()

    with ctxmgr:
        try:
            dologging(args.zmq, args.db)
        except sqlite3.Error as e:
            logger.error("SQL error: " + str(e.args[0]))
        except sqlite3.OperationalError as e:
            logger.error("SQL operataional error: " + str(e.args[0]))
        except:
            e = sys.exc_info()[0]
            logger.error('Exception: ' + str(e))

    logger.error('Exiting')
Пример #2
0
def run():

    with daemon.DaemonContext(
            working_directory='/usr/local/games/dr_evil',
            pidfile=lockfile.FileLock('/usr/local/games/dr_evil/dr_evil.pid')):
        do_evil()
Пример #3
0
    options, _ = parser.parse_args()

    if options.query_timeout:
        TIMEOUT = float(options.query_timeout)
    if options.dns_servers:
        DHOSTS = options.dns_servers.strip(" ,").split(',')
    if options.cache:
        LRUCACHE = lrucache(100)

    print '>> TCP DNS Proxy, https://github.com/henices/Tcp-DNS-proxy'
    print '>> DNS Servers:\n%s' % ('\n'.join(DHOSTS))
    print '>> Query Timeout: %f' % (TIMEOUT)
    print '>> Enable Cache: %r' % (options.cache)
    print '>> Now you can set dns server to 127.0.0.1'

    if options.daemon:
        if os.name == 'nt':
            raise Exception("Windows doesn't support daemon process")
        else:
            try:
                import daemon
                print '>>> Run code in daemon process'
            except ImportError:
                print '*** Please install python-daemon'

    try:
        with daemon.DaemonContext(detach_process=True):
            main()
    except:
        main()
Пример #4
0
     else:
         logging.debug('pidfile (%s) is not locked',
                       constants.NSLCD_PIDFILE)
         sys.exit(1)
 # normal check for pidfile locked
 if pidfile.is_locked():
     logging.error('daemon may already be active, cannot acquire lock (%s)',
                   constants.NSLCD_PIDFILE)
     sys.exit(1)
 # daemonize
 if debugging or nofork:
     ctx = pidfile
 else:
     ctx = daemon.DaemonContext(pidfile=pidfile,
                                signal_map={
                                    signal.SIGTERM: u'terminate',
                                    signal.SIGINT: u'terminate',
                                    signal.SIGPIPE: None,
                                })
 # start daemon
 with ctx:
     try:
         # start normal logging as configured
         if not debugging:
             for method, level in cfg.logs:
                 if method == 'syslog':
                     handler = MySysLogHandler()
                     handler.setFormatter(
                         MyFormatter('%(prefix)s%(message)s'))
                 else:
                     handler = logging.FileHandler(method, encoding='utf-8')
                     handler.setFormatter(
Пример #5
0
    return outputs


# main program
#loadconfiguration('/etc/mm3d/mm3d.ini')
#loadenvirchars('/etc/mm3d/envir.ini')
loadconfiguration('/usr/local/etc/mm3d/mm3d.ini')
loadenvirchars('/usr/local/etc/mm3d/envir.ini')
initports()
first = 1
exttemp = 18
prevtemperature = 0
prevhumidity = 0
previnputs = ""
prevoutputs = ""
with daemon.DaemonContext() as context:
    try:
        while True:
            # read input data from sensor
            writetodebuglog("i", "Measuring T/RH.")
            humidity, temperature = Adafruit_DHT.read_retry(sensor, prt_sens)
            if humidity is not None and temperature is not None:
                wrongvalues = 0
            else:
                wrongvalues = 1
                temperature = 18
                humidity = 72
            temperature = round(temperature)
            humidity = round(humidity)
            writetodebuglog("i", "Measure is done.")
            blinkactled()
Пример #6
0
            
    if option.verbose:
        level = cfg.log.level
    else:
        level = logging.ERROR
    
    logging.basicConfig(level = level,
                        format='%(asctime)s %(levelname)s %(message)s',
                        stream = logfile)
        
    # As the default try to run as daemon. Silently degrade to running as a normal application if this fails
    # unless the user explicitly defined what he expected with the -a / -d parameter. 
    try:
        if option.force_app:
            raise ImportError # Pretend that we couldn't import the daemon lib
        import daemon
    except ImportError:
        if option.force_daemon:
            print('Fatal error, could not daemonize process due to missing "daemon" library, ' \
            'please install the missing dependency and restart the authenticator', file=sys.stderr)
            sys.exit(1)
        do_main_program()
    else:
        context = daemon.DaemonContext(working_directory = sys.path[0],
                                       stderr = logfile)
        context.__enter__()
        try:
            do_main_program()
        finally:
            context.__exit__(None, None, None)
Пример #7
0
 def ipfsDaemonRun(self):
     log = open(("%s/%s" % (self.datadir,"ipfs.log")),'w+')
     with daemon.DaemonContext(stdout=log,stderr=log):
         subprocess.Popen(self.runCmdList)
Пример #8
0
    if not conf.get('ARCHIVE_SERVER'):
        sys.stderr.write(
            'Archive server settings are missing from config file\n')
        sys.exit(1)
    # HubProxy will try to log some stuff, even though we
    # haven't configured our logging handlers yet. So we send logs to stderr
    # temporarily here, and configure it again below.
    log_to_stream(sys.stderr, level=logging.WARNING)
    try:
        transfer = Watchdog(conf=conf)
    except Exception, ex:
        sys.stderr.write("Error starting beaker-transfer: %s\n" % ex)
        sys.exit(1)

    if opts.foreground:
        log_to_stream(sys.stderr, level=logging.DEBUG)
        main_loop(transfer=transfer, conf=conf)
    else:
        # See BZ#977269
        transfer.close()
        with daemon.DaemonContext(pidfile=pidfile.TimeoutPIDLockFile(
                pid_file, acquire_timeout=0),
                                  detach_process=True):
            log_to_syslog('beaker-transfer')
            main_loop(transfer=transfer, conf=conf)


if __name__ == '__main__':
    main()
Пример #9
0
def main():
    args = parse_argv(sys.argv[1:])

    if args.version:
        print('Sendria %s' % __version__)
        sys.exit(0)

    # Do we just want to stop a running daemon?
    if args.stop:
        logger.get().msg(
            'stopping Sendria',
            debug='enabled' if args.debug else 'disabled',
            pidfile=str(args.pidfile) if args.pidfile else None,
        )
        stop(args.pidfile)
        sys.exit(0)

    logger.get().msg(
        'starting Sendria',
        debug='enabled' if args.debug else 'disabled',
        pidfile=str(args.pidfile) if args.pidfile else None,
        db=str(args.db),
        foreground='true' if args.foreground else 'false',
    )

    # Check if the static folder is writable
    if args.autobuild_assets and not os.access(STATIC_DIR, os.W_OK):
        exit_err('autobuilding assets requires write access to %s' %
                 STATIC_DIR)

    if not args.autobuild_assets and (not ASSETS_DIR.exists()
                                      or not list(ASSETS_DIR.glob('*'))):
        exit_err(
            'assets not found. Generate assets using: webassets -m sendria.build_assets build',
            0)

    daemon_kw = {}

    if args.foreground:
        # Do not detach and keep std streams open
        daemon_kw.update({
            'detach_process': False,
            'stdin': sys.stdin,
            'stdout': sys.stdout,
            'stderr': sys.stderr,
        })

    if args.pidfile:
        if args.pidfile.exists():
            try:
                pid = read_pidfile(args.pidfile)
            except Exception as exc:
                exit_err(f'Cannot read pid file: {exc}', 1)

            if not pid_exists(pid):
                logger.get().msg(
                    'deleting obsolete PID file (process %s does not exist)' %
                    pid,
                    pid=pid)
                args.pidfile.unlink()
        daemon_kw['pidfile'] = TimeoutPIDLockFile(str(args.pidfile), 5)

    # Unload threading module to avoid error on exit (it's loaded by lockfile)
    if 'threading' in sys.modules:
        del sys.modules['threading']

    context = daemon.DaemonContext(**daemon_kw)
    with context:
        loop = asyncio.get_event_loop()

        run_sendria_servers(loop, args)

        loop.run_forever()

    logger.get().msg('stop signal received')
    loop.close()

    logger.get().msg('terminating')
    sys.exit(0)
Пример #10
0
    try:
        os.makedirs(args['data_dir'])
    except OSError:
        pass

    lockname = os.path.join(args['data_dir'], LOCK_FILE)
    lock = lockfile.FileLock(lockname)
    if lock.is_locked():
        print '%s is locked! I am probably already running.' % lockname
        print 'If you can find no selfspy process running, it is a stale lock and you can safely remove it.'
        print 'Shutting down.'
        sys.exit(1)

    context = daemon.DaemonContext(working_directory=args['data_dir'],
                                   pidfile=lock,
                                   stderr=sys.stderr)

    context.signal_map = {
        signal.SIGTERM: 'terminate',
        signal.SIGHUP: 'terminate'
    }

    if args['no_text']:
        args['password'] = ""

    if args['password'] is None:
        args['password'] = get_password(verify=check_with_encrypter)

    encrypter = make_encrypter(args['password'])
Пример #11
0
def main():
    print('Launching gerritbot')

    try:
        (opts, args) = getopt.getopt(sys.argv[1:], 'vhc:f',
                                     ['verbose', 'help', 'config'])
    except getopt.GetoptError as err:
        # print help information and exit:
        print(str(err))
        usage()
        sys.exit(2)

    verbose = False
    foreground = False

    config_file = '/etc/gerritbot/gerritbot.yaml'

    for (o, a) in opts:
        if o in ('-v', '--verbose'):
            verbose = True
        elif o in ('-h', '--help'):
            usage()
            sys.exit(1)
        elif o in ('-c', '--config'):
            config_file = a
        elif o == '-f':
            foreground = True

    if not os.path.exists(config_file):
        raise Exception('Unable to read config file at %s' % config_file)

    print('Reading config from ' + config_file)
    config = yaml.load(open(config_file))

    gcfg = config['general']

    # read config files if they are not inline
    for filekey, confkey in {
            'channel_config': 'channels',
            'log_config': 'logging',
            'bot_config': 'ircbot',
            'gerrit_config': 'gerrit'
    }.iteritems():
        if filekey in gcfg and gcfg[filekey] != 'inline':
            config[confkey] = yaml.load(open(gcfg[filekey]))

    logconfig = config['logging']

    if verbose:
        l = logconfig['loggers']
        print("Turning verbosity up to 11")

        maxdebug = {
            'handlers': ['file', 'syslog', 'console'],
            'level': logging.DEBUG,
            'qualname': None
        }

        for k in logconfig['handlers'].keys():
            logconfig['handlers'][k]['level'] = logging.DEBUG

        for qualname in logging.Logger.manager.loggerDict.keys():
            logger = logging.getLogger(qualname)
            logger.handlers = []
            logger.propogate = False
            l[qualname] = maxdebug.copy()
            l[qualname]['qualname'] = qualname

        for qualname in l.keys():
            l[qualname] = maxdebug.copy()
            l[qualname]['qualname'] = qualname


#        l['root']['level'] = logging.CRITICAL
        del l['irc']

    logging.config.dictConfig(logconfig)

    for qualname in logging.Logger.manager.loggerDict.keys():
        print('qualname: ' + qualname)

    global log

    log = logging.getLogger('gerritbot')
    log.propogate = False

    log.debug('Logging initialized for gerritbot')

    if foreground is False:
        pidfile = '/tmp/gerritbot.pid'
        if 'pid' in config['ircbot']:
            pidfile = config['ircbot']['pid']

        log.debug('PID path: ' + pidfile)
        ensure_dir(pidfile)

        pid = pid_file_module.TimeoutPIDLockFile(pidfile, 10)
        log.debug('starting daemonized')
        with daemon.DaemonContext(pidfile=pid):
            _main(config)
    else:
        log.debug('starting in foreground')
        _main(config)
Пример #12
0
    args = parser.parse_args()

    private_data_dir = args.private_data_dir
    pidfile = os.path.join(private_data_dir, 'pid')

    if args.command == 'start':
        # create a file to log stderr in case the daemonized process throws
        # an exception before it gets to `pexpect.spawn`
        stderr_path = os.path.join(private_data_dir, 'artifacts', 'daemon.log')
        if not os.path.exists(stderr_path):
            os.mknod(stderr_path, stat.S_IFREG | stat.S_IRUSR | stat.S_IWUSR)
        stderr = open(stderr_path, 'w+')

        import daemon
        from daemon.pidfile import TimeoutPIDLockFile
        context = daemon.DaemonContext(pidfile=TimeoutPIDLockFile(pidfile),
                                       stderr=stderr)
        with context:
            __run__(private_data_dir)
        sys.exit(0)

    try:
        with open(pidfile, 'r') as f:
            pid = int(f.readline())
    except IOError:
        sys.exit(1)

    if args.command == 'stop':
        try:
            with open(os.path.join(private_data_dir, 'args'), 'r') as args:
                handle_termination(pid, json.load(args), 'bwrap')
        except IOError:
Пример #13
0
def main():
    global handler_logger

    (opts, args) = parse_arguments(sys.argv[1:])

    # Initialize logger
    lvl = logging.DEBUG if opts.debug else logging.INFO
    logger = logging.getLogger("ganeti.eventd")
    logger.setLevel(lvl)
    formatter = logging.Formatter(
        "%(asctime)s %(module)s[%(process)d] %(levelname)s: %(message)s",
        "%Y-%m-%d %H:%M:%S")
    handler = logging.FileHandler(opts.log_file)
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    handler_logger = logger

    # Rename this process so 'ps' output looks like this is a native
    # executable.  Can not seperate command-line arguments from actual name of
    # the executable by NUL bytes, so only show the name of the executable
    # instead.  setproctitle.setproctitle("\x00".join(sys.argv))
    setproctitle.setproctitle(sys.argv[0])

    # Create pidfile
    pidf = daemon.pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10)

    # Remove any stale PID files, left behind by previous invocations
    if daemon.runner.is_pidfile_stale(pidf):
        logger.warning("Removing stale PID lock file %s", pidf.path)
        pidf.break_lock()

    # Become a daemon:
    # Redirect stdout and stderr to handler.stream to catch
    # early errors in the daemonization process [e.g., pidfile creation]
    # which will otherwise go to /dev/null.
    daemon_context = daemon.DaemonContext(pidfile=pidf,
                                          umask=022,
                                          stdout=handler.stream,
                                          stderr=handler.stream,
                                          files_preserve=[handler.stream])
    try:
        daemon_context.open()
    except (daemon.pidlockfile.AlreadyLocked, LockTimeout):
        logger.critical("Failed to lock pidfile %s, another instance running?",
                        pidf.path)
        sys.exit(1)

    logger.info("Became a daemon")

    # Catch signals to ensure graceful shutdown
    signal(SIGINT, fatal_signal_handler)
    signal(SIGTERM, fatal_signal_handler)

    # Monitor the Ganeti job queue, create and push notifications
    wm = pyinotify.WatchManager()
    mask = (pyinotify.EventsCodes.ALL_FLAGS["IN_MOVED_TO"]
            | pyinotify.EventsCodes.ALL_FLAGS["IN_CLOSE_WRITE"])

    cluster_name = find_cluster_name()

    handler = JobFileHandler(logger, cluster_name)
    notifier = pyinotify.Notifier(wm, handler)

    try:
        # Fail if adding the inotify() watch fails for any reason
        res = wm.add_watch(constants.QUEUE_DIR, mask)
        if res[constants.QUEUE_DIR] < 0:
            raise Exception("pyinotify add_watch returned negative descriptor")

        logger.info("Now watching %s of %s" %
                    (constants.QUEUE_DIR, cluster_name))

        while True:  # loop forever
            # process the queue of events as explained above
            notifier.process_events()
            if notifier.check_events():
                # read notified events and enqeue them
                notifier.read_events()
    except SystemExit:
        logger.info("SystemExit")
    except:
        logger.exception("Caught exception, terminating")
    finally:
        # destroy the inotify's instance on this interrupt (stop monitoring)
        notifier.stop()
        raise
Пример #14
0
    " org.apache.phoenix.tracingwebapp.http.Main " + args

if command == 'start':
    if not daemon_supported:
        print >> sys.stderr, "daemon mode not supported on this platform"
        sys.exit(-1)

    # run in the background
    d = os.path.dirname(out_file_path)
    if not os.path.exists(d):
        os.makedirs(d)
    with open(out_file_path, 'a+') as out:
        context = daemon.DaemonContext(
            pidfile=daemon.PidFile(
                pid_file_path,
                'Trace Server already running, PID file found: %s' %
                pid_file_path),
            stdout=out,
            stderr=out,
        )
        print 'starting Trace Server, logging to %s' % log_file_path
        with context:
            # this block is the main() for the forked daemon process
            child = None
            cmd = java_cmd % {
                'java': java,
                'root_logger': 'INFO,DRFA',
                'log_dir': phoenix_log_dir,
                'log_file': phoenix_log_file
            }

            # notify the child when we're killed
Пример #15
0
def main():
    _parser = argparse.ArgumentParser()
    _parser.add_argument("-d", dest="daemonize", default=False, action="store_true", help="daemonize process [%(default)s]")
    _parser.add_argument("--progname", default="", type=str, help="programm name for sys.argv [%(default)s]")
    _parser.add_argument("--modname", default="", type=str, help="python module to load [%(default)s]")
    _parser.add_argument("--main-name", default="main", type=str, help="name of main function [%(default)s]")
    _parser.add_argument("--exename", default="", type=str, help="exe to start [%(default)s]")
    _parser.add_argument("--proctitle", default="", type=str, help="process title to set [%(default)s]")
    _parser.add_argument("--user", type=str, default="root", help="user to use for the process [%(default)s]")
    _parser.add_argument("--group", type=str, default="root", help="group to use for the process [%(default)s]")
    _parser.add_argument("--groups", type=str, default="", help="comma-separated list of groups for the process [%(default)s]")
    _parser.add_argument("--nice", type=int, default=0, help="set nice level of new process [%(default)d]")
    _parser.add_argument("--debug", default=False, action="store_true", help="enable debug mode (modify sys.path), [%(default)s]")
    _parser.add_argument("extra_args", nargs="*", help="extra arguments for module [%(default)s]")
    opts = _parser.parse_args()
    if opts.exename:
        _mode = "exe"
        _args = [opts.exename]
    else:
        _mode = "python"
        _args = [opts.progname]
    if opts.user != "root":
        uid = get_uid_from_name(opts.user)[0]
    else:
        uid = 0
    if opts.group != "root":
        gid = get_gid_from_name(opts.group)[0]
    else:
        gid = 0
    if opts.groups.strip():
        gids = [get_gid_from_name(_gid)[0] for _gid in opts.groups.strip().split(",")]
    else:
        gids = []
    _daemon_context = daemon.DaemonContext(
        detach_process=True,
        uid=uid,
        gid=gid,
        # gids=gids,
        # valid with python-daemonize-2.1.2
        # init_groups=False
    )
    if opts.nice:
        os.nice(opts.nice)
    if opts.daemonize:
        try:
            _daemon_context.open()
        except:
            # catastrophe
            from initat.tools import logging_tools, process_tools
            for _line in process_tools.icswExceptionInfo().log_lines:
                logging_tools.my_syslog(_line, logging_tools.LOG_LEVEL_ERROR)
    else:
        if gids:
            os.setgroups(gids)
        if uid or gid:
            os.setgid(gid)
            os.setuid(uid)
    if opts.extra_args:
        _args.extend(opts.extra_args)
    if _mode == "python":
        os.environ["LC_LANG"] = "en_us.UTF_8"
        # python path
        if opts.debug:
            # check via commandline args, do NOT import anything below init.at here
            abs_path = os.path.dirname(__file__)
            abs_path = os.path.split(os.path.split(abs_path)[0])[0]
            sys.path.insert(0, abs_path)
        sys.argv = _args
        setproctitle.setproctitle(opts.proctitle)
        main_module = importlib.import_module(opts.modname)
        if opts.daemonize:
            # redirect IO-streams
            from initat.logging_server.constants import icswLogHandleTypes
            from initat.tools.io_stream_helper import icswIOStream
            sys.stdout = icswIOStream(icswLogHandleTypes.log_py)
            sys.stderr = icswIOStream(icswLogHandleTypes.err_py)
        getattr(main_module, opts.main_name)()
        # was: main_module.main()
    else:
        # path for standard exe (munge, redis)
        setproctitle.setproctitle(opts.proctitle)
        os.execv(_args[0], _args)
Пример #16
0
    def execute(self, *args, **options):
        """
        Takes the options and starts a daemon context from them.

        Example::

            python manage.py linkconsumer --pidfile=/var/run/cb_link.pid
                --stdout=/var/log/cb/links.out --stderr=/var/log/cb/links.err

        """
        # print 20130610, 'execute', __file__

        # print options

        if daemon is not None:

            context = daemon.DaemonContext()

            context.chroot_directory = self.get_option_value(
                options, 'chroot_directory')
            context.working_directory = self.get_option_value(
                options, 'working_directory', '/')
            context.umask = self.get_option_value(options, 'umask', 0)
            context.detach_process = self.get_option_value(
                options, 'detach_process')
            context.prevent_core = self.get_option_value(
                options, 'prevent_core', True)
            if self.preserve_loggers:
                context.files_preserve = get_logger_files(
                    self.preserve_loggers)

            # Get file objects
            # stdin =  self.get_option_value(options, 'stdin')
            stdin = options.pop('stdin', None)
            if stdin is not None:
                options['stdin'] = context.stdin = open(stdin, "r")

            # stdout = self.get_option_value(options, 'stdout')
            stdout = options.pop('stdout', None)
            if stdout is not None:
                options['stdout'] = context.stdout = open(stdout, "a+")

            # stderr = self.get_option_value(options, 'stderr')
            stderr = options.pop('stderr', None)
            if stderr is not None:
                self.stderr = options['stderr'] = context.stderr = open(
                    stderr, "a+")
            # self.stderr is needed in case there is an exception
            # during execute.  Django then would try to write to
            # sys.stderr which is None because we are a daemon

            # Make pid lock file
            pidfile = self.get_option_value(options, 'pidfile')
            if pidfile is not None:
                # context.pidfile=pidlockfile.PIDLockFile(pidfile)
                context.pidfile = pidlockfile.TimeoutPIDLockFile(pidfile, 0)

            uid = self.get_option_value(options, 'uid')
            if uid is not None:
                context.uid = int(uid)

            gid = self.get_option_value(options, 'gid')
            if gid is not None:
                context.gid = int(gid)

            context.open()

        # Django 1.5.1 needs them:
        # for k in ('stdout','stderr'):
        #     options[k] = getattr(context,k,None)

        # self.handle_daemon(*args, **options)
        BaseCommand.execute(self, *args, **options)
Пример #17
0
    def run(self):
        """Startup the processing and go!"""
        self.terminate = threading.Event()
        atexit.register(self.shutdown)
        self.context = daemon.DaemonContext(detach_process=True)
        iter = 0

        if Bcfg2.Options.setup.daemon:
            self.logger.debug("Daemonizing")
            self.context.pidfile = TimeoutPIDLockFile(
                Bcfg2.Options.setup.daemon, acquire_timeout=5)
            # Attempt to ensure lockfile is able to be created and not stale
            try:
                self.context.pidfile.acquire()
            except LockFailed:
                self.logger.error("Failed to daemonize: %s" %
                                  sys.exc_info()[1])
                self.shutdown()
                return
            except LockTimeout:
                try: # attempt to break the lock
                    os.kill(self.context.pidfile.read_pid(), 0)
                except (OSError, TypeError): # No process with locked PID
                    self.context.pidfile.break_lock()
                else:
                    self.logger.error("Failed to daemonize: "
                                      "Failed to acquire lock on %s" %
                                      Bcfg2.Options.setup.daemon)
                    self.shutdown()
                    return
            else:
                self.context.pidfile.release()

            self.context.open()
            self.logger.info("Starting daemon")

        self.transport.start_monitor(self)

        while not self.terminate.isSet():
            try:
                interaction = self.transport.fetch()
                if not interaction:
                    continue
                if self.semaphore:
                    self.semaphore.acquire()
                store_thread = ReportingStoreThread(interaction, self.storage,
                                                    semaphore=self.semaphore)
                store_thread.start()
                self.children.append(store_thread)

                iter += 1
                if iter >= self.cleanup_threshold:
                    self.reap_children()
                    iter = 0

            except (SystemExit, KeyboardInterrupt):
                self.logger.info("Shutting down")
                self.shutdown()
            except:
                self.logger.error("Unhandled exception in main loop %s" %
                                  sys.exc_info()[1])
Пример #18
0
def main():
    parser = argparse.ArgumentParser(description='manage ansible execution')

    parser.add_argument('--version', action='version', version=VERSION)

    parser.add_argument('command', choices=['run', 'start', 'stop', 'is-alive'])

    parser.add_argument('private_data_dir',
                        help='Base directory containing Runner metadata (project, inventory, etc')

    group = parser.add_mutually_exclusive_group()

    group.add_argument("-p", "--playbook", default=DEFAULT_RUNNER_PLAYBOOK,
                       help="The name of the playbook to execute")

    group.add_argument("-r", "--role", default=DEFAULT_RUNNER_ROLE,
                       help="Invoke an Ansible role directly without a playbook")

    parser.add_argument("--hosts",
                        help="Define the set of hosts to execute against")

    parser.add_argument("-i", "--ident",
                        default=uuid4(),
                        help="An identifier that will be used when generating the"
                             "artifacts directory and can be used to uniquely identify a playbook run")

    parser.add_argument("--rotate-artifacts",
                        default=0,
                        type=int,
                        help="Automatically clean up old artifact directories after a given number has been created, the default is 0 which disables rotation")

    parser.add_argument("--roles-path", default=DEFAULT_ROLES_PATH,
                        help="Path to the Ansible roles directory")

    parser.add_argument("--role-vars",
                        help="Variables to pass to the role at runtime")

    parser.add_argument("--role-skip-facts", action="store_true", default=False,
                        help="Disable fact collection when executing a role directly")
    parser.add_argument("--artifact-dir",
                        help="Optional Path for the artifact root directory, by default it is located inside the private data dir")

    parser.add_argument("--inventory",
                        help="Override the default inventory location in private_data_dir")

    parser.add_argument("-j", "--json", action="store_true",
                        help="Output the json event structure to stdout instead of Ansible output")

    parser.add_argument("-v", action="count",
                        help="Increase the verbosity with multiple v's (up to 5) of the ansible-playbook output")

    parser.add_argument("-q", "--quiet", action="store_true",
                        help="Disable all output")

    parser.add_argument("--cmdline",
                        help="Command line options to pass to ansible-playbook at execution time")
    parser.add_argument("--debug", action="store_true",
                        help="Enable Runner debug output logging")

    parser.add_argument("--logfile",
                        help="Log output messages to a file")

    args = parser.parse_args()

    output.configure()

    # enable or disable debug mode
    output.set_debug('enable' if args.debug else 'disable')

    # set the output logfile
    if args.logfile:
        output.set_logfile(args.logfile)

    output.debug('starting debug logging')

    pidfile = os.path.join(args.private_data_dir, 'pid')

    try:
        os.makedirs(args.private_data_dir)
    except OSError as exc:
        if exc.errno == errno.EEXIST and os.path.isdir(args.private_data_dir):
            pass
        else:
            raise

    if args.command != 'run':
        stderr_path = os.path.join(args.private_data_dir, 'daemon.log')
        if not os.path.exists(stderr_path):
            os.close(os.open(stderr_path, os.O_CREAT, stat.S_IRUSR | stat.S_IWUSR))
        stderr = open(stderr_path, 'w+')

    if args.command in ('start', 'run'):
        if args.role:
            role = {'name': args.role}
            if args.role_vars:
                role_vars = {}
                for item in shlex.split(args.role_vars):
                    key, value = item.split('=')
                    role_vars[key] = value
                role['vars'] = role_vars

            kwargs = dict(private_data_dir=args.private_data_dir,
                          json_mode=args.json,
                          ignore_logging=False,
                          rotate_artifacts=args.rotate_artifacts)
            if args.artifact_dir:
                kwargs['artifact_dir'] = args.artifact_dir

            project_path = os.path.abspath(os.path.join(args.private_data_dir, 'project'))
            project_exists = os.path.exists(project_path)

            env_path = os.path.join(args.private_data_dir, 'env')
            env_exists = os.path.exists(env_path)

            envvars_path = os.path.join(args.private_data_dir, 'env/envvars')
            envvars_exists = os.path.exists(envvars_path)

            if args.cmdline:
                kwargs['cmdline'] = args.cmdline

            playbook = None
            tmpvars = None

            rc = 255
            errmsg = None

            try:
                play = [{'hosts': args.hosts if args.hosts is not None else "all",
                         'gather_facts': not args.role_skip_facts,
                         'roles': [role]}]

                filename = str(uuid4().hex)

                playbook = dump_artifact(json.dumps(play), project_path, filename)
                kwargs['playbook'] = playbook
                output.debug('using playbook file %s' % playbook)

                if args.inventory:
                    inventory_file = os.path.abspath(os.path.join(args.private_data_dir, 'inventory', args.inventory))
                    if not os.path.exists(inventory_file):
                        raise AnsibleRunnerException('location specified by --inventory does not exist')
                    kwargs['inventory'] = inventory_file
                    output.debug('using inventory file %s' % inventory_file)

                roles_path = args.roles_path or os.path.join(args.private_data_dir, 'roles')
                roles_path = os.path.abspath(roles_path)
                output.debug('setting ANSIBLE_ROLES_PATH to %s' % roles_path)

                envvars = {}
                if envvars_exists:
                    with open(envvars_path, 'rb') as f:
                        tmpvars = f.read()
                        envvars = safe_load(tmpvars)

                envvars['ANSIBLE_ROLES_PATH'] = roles_path
                kwargs['envvars'] = envvars

                res = run(**kwargs)
                rc = res.rc

            except AnsibleRunnerException as exc:
                errmsg = str(exc)

            finally:
                if not project_exists and os.path.exists(project_path):
                    logger.debug('removing dynamically generated project folder')
                    shutil.rmtree(project_path)
                elif playbook and os.path.isfile(playbook):
                    logger.debug('removing dynamically generated playbook')
                    os.remove(playbook)

                # if a previous envvars existed in the private_data_dir,
                # restore the original file contents
                if tmpvars:
                    with open(envvars_path, 'wb') as f:
                        f.write(tmpvars)
                elif not envvars_exists and os.path.exists(envvars_path):
                    logger.debug('removing dynamically generated envvars folder')
                    os.remove(envvars_path)

                # since ansible-runner created the env folder, remove it
                if not env_exists and os.path.exists(env_path):
                    logger.debug('removing dynamically generated env folder')
                    shutil.rmtree(env_path)

            if errmsg:
                print('ansible-runner: ERROR: %s' % errmsg)

            sys.exit(rc)

        elif args.command == 'start':
            import daemon
            from daemon.pidfile import TimeoutPIDLockFile
            context = daemon.DaemonContext(
                pidfile=TimeoutPIDLockFile(pidfile),
                stderr=stderr
            )
        else:
            context = threading.Lock()

        with context:
            run_options = dict(private_data_dir=args.private_data_dir,
                               ident=args.ident,
                               playbook=args.playbook,
                               verbosity=args.v,
                               quiet=args.quiet,
                               rotate_artifacts=args.rotate_artifacts,
                               ignore_logging=False,
                               json_mode=args.json)

            if args.hosts is not None:
                run_options.update(inventory=args.hosts)

            if args.cmdline:
                run_options['cmdline'] = args.cmdline

            if args.artifact_dir:
                kwargs['artifact_dir'] = args.artifact_dir

            res = run(**run_options)
            sys.exit(res.rc)

    try:
        with open(pidfile, 'r') as f:
            pid = int(f.readline())
    except IOError:
        sys.exit(1)

    if args.command == 'stop':
        try:
            with open(os.path.join(args.private_data_dir, 'args'), 'r') as args:
                Runner.handle_termination(pid, json.load(args), 'bwrap')
        except IOError:
            Runner.handle_termination(pid, [], 'bwrap')

    elif args.command == 'is-alive':
        try:
            os.kill(pid, signal.SIG_DFL)
            sys.exit(0)
        except OSError:
            sys.exit(1)
Пример #19
0
def main(device_type):
    """Run ssh-agent using given hardware client factory."""
    args = create_agent_parser(device_type=device_type).parse_args()
    util.setup_logging(verbosity=args.verbose, filename=args.log_file)

    public_keys = None
    filename = None
    if args.identity.startswith('/'):
        filename = args.identity
        contents = open(filename, 'rb').read().decode('utf-8')
        # Allow loading previously exported SSH public keys
        if filename.endswith('.pub'):
            public_keys = list(import_public_keys(contents))
        identities = list(parse_config(contents))
    else:
        identities = [
            device.interface.Identity(identity_str=args.identity,
                                      curve_name=args.ecdsa_curve_name)
        ]
    for index, identity in enumerate(identities):
        identity.identity_dict['proto'] = 'ssh'
        log.info('identity #%d: %s', index, identity.to_string())

    # override default PIN/passphrase entry tools (relevant for TREZOR/Keepkey):
    device_type.ui = device.ui.UI(device_type=device_type, config=vars(args))

    conn = JustInTimeConnection(
        conn_factory=lambda: client.Client(device_type()),
        identities=identities,
        public_keys=public_keys)

    sock_path = _get_sock_path(args)
    command = args.command
    context = _dummy_context()
    if args.connect:
        command = ['ssh'] + ssh_args(conn) + args.command
    elif args.mosh:
        command = ['mosh'] + mosh_args(conn) + args.command
    elif args.daemonize:
        out = 'SSH_AUTH_SOCK={0}; export SSH_AUTH_SOCK;\n'.format(sock_path)
        sys.stdout.write(out)
        sys.stdout.flush()
        context = daemon.DaemonContext()
        log.info('running the agent as a daemon on %s', sock_path)
    elif args.foreground:
        log.info('running the agent on %s', sock_path)

    use_shell = bool(args.shell)
    if use_shell:
        command = os.environ['SHELL']
        sys.stdin.close()

    if command or args.daemonize or args.foreground:
        with context:
            return run_server(conn=conn,
                              command=command,
                              sock_path=sock_path,
                              debug=args.debug,
                              timeout=args.timeout)
    else:
        for pk in conn.public_keys():
            sys.stdout.write(pk)
        return 0  # success exit code
Пример #20
0
if newpid == 0:
    print("Mining monitor started.")
    sys.exit(0)

try:
    os.setsid(
    )  # if 'fork failed: 1 (Operation not permitted)', it's just due to python's
except OSError as ex:
    newpid = newpid  #  exception when you are already the group-leader ...
os.umask(0)

### Ref: https://dpbl.wordpress.com/2017/02/12/a-tutorial-on-python-daemon/
with daemon.DaemonContext(chroot_directory=None,
                          working_directory='/var/mining',
                          files_preserve=[logFH.stream],
                          signal_map={
                              signal.SIGTERM: shutdown,
                              signal.SIGTSTP: shutdown
                          },
                          pidfile=lockfile.LockFile(config.PIDFILE)):
    pid = os.getpid()
    with open(config.PIDFILE, 'w') as fh:
        fh.write(str(pid))

    schedule.every(5).minutes.do(monitor_miners)
    schedule.every().day.at("4:30").do(cap_diff)
    logger.info("Miners Monitor started, pid=%i", pid)

    while True:
        schedule.run_pending()
        time.sleep(1)
Пример #21
0
def start_daemon():
    import daemon
    with daemon.DaemonContext():
        watch()
Пример #22
0
                    # the current next_val
                    previous_values[pool.name] = next_val.copy()
            with lock:
                zpoolio_one = rv.copy()
                zpoolio_all = previous_values.copy()


if __name__ == '__main__':

    pidfile = PidFile(PIDFILE)

    context = daemon.DaemonContext(
        working_directory='/root',
        umask=0o002,
        pidfile=pidfile,
        stdout=sys.stdout,
        stdin=sys.stdin,
        stderr=sys.stderr,
        detach_process=True,
        signal_map={signal.SIGTERM: cust_terminate},
    )

    with context:
        setproctitle('freenas-snmpd')
        loop_thread = Loop_Sockserver()
        loop_thread.start()
        z1 = zilOneWorker()
        z5 = zilFiveWorker()
        z10 = zilTenWorker()
        zio = zpoolioWorker()
        z1.start()
        z5.start()
Пример #23
0
        GPIO.output(self.in1_right, GPIO.LOW)
        GPIO.output(self.in2_right, GPIO.HIGH)
        self.p_left.ChangeDutyCycle(75)
        self.p_right.ChangeDutyCycle(75)

    def joystick(self, right, left):
        if right >= 0:
            GPIO.output(self.in1_right, GPIO.LOW)
            GPIO.output(self.in2_right, GPIO.HIGH)
        else:
            GPIO.output(self.in1_right, GPIO.HIGH)
            GPIO.output(self.in1_right, GPIO.LOW)
        if left >= 0:
            GPIO.output(self.in1_left, GPIO.LOW)
            GPIO.output(self.in2_left, GPIO.HIGH)
        else:
            GPIO.output(self.in1_left, GPIO.HIGH)
            GPIO.output(self.in2_left, GPIO.LOW)
        self.p_left.ChangeDutyCycle(abs(left))
        self.p_right.ChangeDutyCycle(abs(right))

    def exit(self):
        GPIO.cleanup()
        print("GPIO Clean up")


speedy = Speedy()

if __name__ == '__main__':
    with daemon.DaemonContext():
        speedy.run()
Пример #24
0
        print >> sys.stderr, "daemon mode not supported on this platform"
        sys.exit(-1)

    if filename == '':
        print >> sys.stderr, "Need config file as input"
        sys.exit(-1)

    # run in the background
    d = os.path.dirname(out_file_path)
    if not os.path.exists(d):
        os.makedirs(d)

    with open(out_file_path, 'a+') as out:
        context = daemon.DaemonContext(
            pidfile=pidfile.PIDLockFile(pid_file_path),
            stdout=out,
            stderr=out,
        )
        with context:
            # this block is the main() for the forked daemon process
            child = None
            cmd = java_cmd % {'java': java}
            print >> sys.stderr, cmd

            # notify the child when we're killed
            def handler(signum, frame):
                if child:
                    child.send_signal(signum)
                sys.exit(0)

            signal.signal(signal.SIGTERM, handler)
Пример #25
0
if __name__ == '__main__':

    parser = argparse.ArgumentParser(description="YOGA")
    parser.add_argument('--pid', default='/var/run/yoga.pid')
    parser.add_argument('--log', default='/var/log/yoga/')
    parser.add_argument('--port', default=5005)
    parser.add_argument('--host', default='0.0.0.0')
    parser.add_argument('--debug', default=False)
    parser.add_argument('action', default="foreground")

    args = parser.parse_args()

    if args.action == "start":
        with daemon.DaemonContext(
                working_directory=".",
                stdout=open(os.path.join(args.log, "out.log"), "w"),
                stderr=open(os.path.join(args.log, "err.log"), "w"),
                pidfile=pidfile.TimeoutPIDLockFile(args.pid)):
            app.debug = args.debug
            app.run(host=args.host, port=args.port)

    elif args.action == "status":
        if os.path.isfile(args.pid):
            with open(args.pid, "r") as f:
                pid = int(f.read())
                p = psutil.Process(pid)
                status = "running (pid: %i, name: %s, cmd: %s)" % (
                    pid, p.name(), p.cmdline())
        else:
            status = "not running (reason: PID file not found!)"
        print("status: %s" % (status))
Пример #26
0
def main():
    global SETUID_USER, SETGID_GROUP
    options = parse_args()
    SETUID_USER = options.user
    SETGID_GROUP = options.group
    root = desktop.lib.paths.get_run_root()
    log_dir = os.path.join(root, options.log_dir)

    if options.show_supervisees:
        for name, supervisee in get_supervisees().iteritems():
            if name not in options.supervisee_exclusions:
                print(name)
        sys.exit(0)

    # Let our children know
    os.environ['DESKTOP_LOG_DIR'] = log_dir

    if not os.path.exists(log_dir):
        os.makedirs(log_dir)

    setup_user_info()

    pid_file = os.path.abspath(os.path.join(root, options.pid_file))
    pidfile_context = TimeOutPIDLockFile(pid_file, LOCKFILE_TIMEOUT)

    existing_pid = pidfile_context.read_pid()
    if existing_pid:
        cmdline = get_pid_cmdline(existing_pid)
        if not cmdline.strip():
            # pid is not actually running
            pidfile_context.break_lock()
        else:
            LOG.error(
                "Pid file %s indicates that Hue is already running (pid %d)" %
                (pid_file, existing_pid))
            sys.exit(1)
    elif pidfile_context.is_locked():
        # If there's no pidfile but there is a lock, it's a strange situation,
        # but we should break the lock because it doesn't seem to be actually running
        logging.warn("No existing pid file, but lock exists. Breaking lock.")
        pidfile_context.break_lock()

    if options.daemonize:
        outfile = file(os.path.join(log_dir, 'supervisor.out'), 'a+', 0)
        context = daemon.DaemonContext(
            working_directory=root,
            pidfile=pidfile_context,
            stdout=outfile,
            stderr=outfile,
        )

        context.signal_map = {
            signal.SIGTERM: sig_handler,
        }

        context.open()
    os.umask(022)

    # Log initialization must come after daemonization, which closes all open files.
    # Log statements before this point goes to stderr.
    _init_log(log_dir)

    sups = []
    try:
        for name, supervisee in get_supervisees().iteritems():

            if name in options.supervisee_exclusions:
                continue

            if supervisee.drop_root:
                preexec_fn = drop_privileges
            else:
                preexec_fn = None

            if options.daemonize:
                log_stdout = file(os.path.join(log_dir, name + '.out'), 'a+',
                                  0)
                log_stderr = log_stdout
            else:
                # Passing None to subprocess.Popen later makes the subprocess inherit the
                # standard fds from the supervisor
                log_stdout = None
                log_stderr = None
            sup = Supervisor(supervisee.cmdv,
                             stdout=log_stdout,
                             stderr=log_stderr,
                             preexec_fn=preexec_fn)
            sup.start()
            sups.append(sup)

        wait_loop(sups, options)
    except MyBaseException, ex:
        LOG.exception("Exception in supervisor main loop")
        shutdown(sups)  # shutdown() exits the process
Пример #27
0
    # exit main routine and program

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description="Split sFlow data based on destination AS number")
    parser.add_argument("-c", "--configfile", help="Configuration file")
    parser.add_argument("-d",
                        "--nodaemon",
                        default=False,
                        action='store_true',
                        help="Do not enter daemon mode")
    parser.add_argument("-v",
                        "--verbose",
                        default=False,
                        help="Show action of playlist player")

    #    (options, args) = parser.parse_args()
    options = parser.parse_args()
    if options.configfile != None:
        config['configfile'] = options.configfile

    cfg = read_config(config, config['configfile'], 'common')

    fileout = open(cfg['outfile'], "w")
    if not options.nodaemon:
        with daemon.DaemonContext(stderr=fileout, stdout=fileout):
            mainroutine()
        fileout.close()
    else:
        mainroutine()
Пример #28
0
def main():
    """
    Runs MQTT loop to publish LifeSOS states.
    """

    # Display application header
    print("{} v{} - {}\n".format(PROJECT_NAME, PROJECT_VERSION,
                                 PROJECT_DESCRIPTION))

    # Parse command line arguments
    parser = argparse.ArgumentParser(prog="{}".format(PROJECT_NAME))
    group = parser.add_mutually_exclusive_group()
    group.add_argument('-e',
                       '--devices',
                       help="list devices enrolled on base unit and exit",
                       action='store_true')
    parser.add_argument('-v',
                        '--verbose',
                        help="display all logging output.",
                        action='store_true')
    group.add_argument(
        '-d',
        '--daemon',
        help="put the application into the background after starting",
        action='store_true')
    parser.add_argument(
        '-w',
        '--workdir',
        help="work directory used to store config, log and pid files "
        "(default: %(default)s)",
        default=DEFAULT_WORKDIR)
    parser.add_argument('-c',
                        '--configfile',
                        help="configuration file name (default: %(default)s)",
                        default=DEFAULT_CONFIGFILE)
    parser.add_argument(
        '-l',
        '--logfile',
        help="if specified, will write to a daily rolling log file "
        "(default: %(default)s)",
        nargs='?',
        const=DEFAULT_LOGFILE)
    parser.add_argument(
        '-p',
        '--pidfile',
        help="if specified, file will be create to record the process ID and "
        "is used for locking (default: %(default)s)",
        nargs='?',
        const=DEFAULT_PIDFILE)
    args = parser.parse_args()

    # Change to the work directory; create if needed
    workdir = os.path.expanduser(os.path.expandvars(args.workdir))
    if not os.path.isdir(workdir):
        os.mkdir(workdir)
    os.chdir(workdir)

    # Create log handlers; attach daily rolling log file handler if needed
    handlers = [logging.StreamHandler()]
    logfile_handler = None
    if args.logfile:
        logfile = os.path.expanduser(os.path.expandvars(args.logfile))
        logfile_handler = logging.handlers.TimedRotatingFileHandler(
            logfile, when='midnight', backupCount=5)
        handlers.append(logfile_handler)

    # Configure logger format, and set Debug level if verbose arg specified
    logging.basicConfig(
        format=
        "%(asctime)s %(levelname)-5s (%(threadName)s) [%(name)s] %(message)s",
        datefmt='%Y-%m-%d %H:%M:%S',
        level=None if not args.verbose else logging.DEBUG,
        handlers=handlers)

    # The python-daemin library isn't compatible with Windows
    if args.daemon and os.name == 'nt':
        _LOGGER.error("Daemon is not supported on Windows")
        sys.exit(EX_CONFIG)

    # Load the configuration file, or create default if none exists
    config = Config.load(args.configfile)
    if not config:
        sys.exit(EX_CONFIG)
    elif config.is_default:
        print("\nA default configuration file has been created:\n{}\n\n"
              "Please edit any settings as needed then restart.".format(
                  os.path.abspath(args.configfile)))
        sys.exit(EX_CONFIG)

    # Apply the config settings to logger system
    _apply_logger_config(config, args)

    # List devices only and exit
    if args.devices:
        _list_devices(config)
        sys.exit(EX_OK)

    # Run the translator
    if args.daemon:
        import daemon
        from daemon.pidfile import TimeoutPIDLockFile
        print("Starting daemon.")
        with daemon.DaemonContext(
            working_directory=workdir,
            stderr=None if not args.verbose else sys.stderr,
            pidfile=None if not args.pidfile else \
                    TimeoutPIDLockFile(args.pidfile, acquire_timeout=-1),
            files_preserve=[None if not logfile_handler else \
                                    logfile_handler.stream.fileno()],
        ):
            _run_translator(config)
    else:
        _run_translator(config)
Пример #29
0
 def run(self, handle_opts=True):
     if handle_opts:
         opts = self.handle_opts()
         errors = self.config.merge_opts(opts)
         if errors:
             if errors:
                 self.die(errors)
         if opts.gen_config:
             self.config.write()
             sys.exit(0)
         if opts.config_path:
             errors = self.config.read_file(opts.config_path)
             if errors:
                 self.die(errors)
     (uid, gid) = self.get_uid_gid()
     self.uid = uid
     self.gid = gid
     if self.config.logging_method == 'file':
         self._check_create_log_file(uid, gid)
         try:
             self.log_file = open(self.config.log_file, 'a')
             self.on_stop(lambda: self.log_file.flush())
             self.on_stop(lambda: self.log_file.close())
             self.on_hup(lambda: self._reopen_log_files())
         except IOError:
             self.die("Could not access log file %s" % self.config.log_file)
         self._log_fmt = '\t'.join(
             ('fakemtpd', '%(asctime)s', socket.gethostname(),
              '%(process)s', '%(name)s', '%(levelname)s', '%(message)s'))
     else:
         self.log_file = None
     if self.config.logging_method == 'syslog':
         self._log_fmt = 'fakemtpd[%(process)d]: %(message)s'
     else:
         self._log_fmt = '\t'.join(
             ('fakemtpd', '%(asctime)s', socket.gethostname(),
              '%(process)s', '%(name)s', '%(levelname)s', '%(message)s'))
     if self.config.pid_file:
         pidfile = BetterLockfile(os.path.realpath(self.config.pid_file))
         try:
             pidfile.acquire()
         except lockfile.AlreadyLocked:
             self.die("%s is already locked; another instance running?" %
                      self.config.pid_file)
         pidfile.release()
     else:
         pidfile = None
     # Do this before daemonizing so that the user can see any errors
     # that may occur
     sock = self.bind()
     self.config.merge_sock(sock)
     if self.config.daemonize:
         d = daemon.DaemonContext(
             files_preserve=[pidfile.file, self.log_file, sock],
             pidfile=pidfile,
             stdout=self.log_file,
             stderr=self.log_file)
         self.on_stop_user(d.close)
         d.open()
     elif self.config.log_file:
         os.dup2(self.log_file.fileno(), sys.stdout.fileno())
         os.dup2(self.log_file.fileno(), sys.stderr.fileno())
     if self.config.pid_file:
         self.on_stop_user(pidfile.destroy)
     signal.signal(signal.SIGINT, lambda signum, frame: self._signal_stop())
     signal.signal(signal.SIGTERM,
                   lambda signum, frame: self._signal_stop())
     signal.signal(signal.SIGHUP, lambda signum, frame: self._signal_hup())
     # This needs to happen after daemonization
     self._setup_logging()
     logging.info("Bound on port %d", self.config.port)
     if pidfile:
         print >> pidfile.file, os.getpid()
         pidfile.file.flush()
     io_loop = self.create_loop(sock)
     self.maybe_drop_privs()
     self.on_stop(io_loop.stop)
     logging.getLogger().handlers[0].flush()
     self._start(io_loop)
Пример #30
0
def run():
    with daemon.DaemonContext():
        do_something()