def main(): parser = argparse.ArgumentParser() parser.add_argument("-c", "--config", required=True, help="Path to yaml config file.") parser.add_argument("-d", "--debuglog", help="Enable debug log. " "Specifies file to write log to.") parser.add_argument("--foreground", action='store_true', help="Run in the foreground.") parser.add_argument("-p", "--pidfile", default="/var/run/jenkins-log-pusher/" "jenkins-log-gearman-client.pid", help="PID file to lock during daemonization.") args = parser.parse_args() with open(args.config, 'r') as config_stream: config = yaml.load(config_stream) server = Server(config, args.debuglog) if args.foreground: server.setup_logging() server.main() else: pidfile = pidfile_mod.TimeoutPIDLockFile(args.pidfile, 10) with daemon.DaemonContext(pidfile=pidfile): server.setup_logging() server.main()
def main(): parser = argparse.ArgumentParser() parser.add_argument("--port", type=int, default=0, help="listening port for switch") parser.add_argument( "--statusfile", help="file to record status; useful for communications") parser.add_argument("--pidfile", help="file to record pid; useful for communciations") args = parser.parse_args() pidFileName = os.path.expanduser(os.path.expandvars(args.pidfile)) statusFileName = os.path.expanduser(os.path.expandvars(args.statusfile)) pidFileDir = os.path.dirname(pidFileName) with daemon.DaemonContext( working_directory=pidFileDir, umask=0o002, pidfile=pidfile.TimeoutPIDLockFile(pidFileName), ) as context: runSwitch(args.port, statusFileName)
def main(): parser = argparse.ArgumentParser() parser.add_argument("--private", action="store_true", help="Only accept local connections.") parser.add_argument("--port", type=int, default=0, help="listening port for switch") parser.add_argument( "--statusfile", help="file to record status; useful for communications") parser.add_argument("--pidfile", help="file to record pid; useful for communciations") args = parser.parse_args() pidFileName = os.path.expanduser(os.path.expandvars(args.pidfile)) statusFileName = os.path.expanduser(os.path.expandvars(args.statusfile)) pidFileDir = os.path.dirname(pidFileName) host = None if args.private: host = "127.0.0.1" with daemon.DaemonContext( working_directory=pidFileDir, umask=0o002, pidfile=pidfile.TimeoutPIDLockFile(pidFileName), ) as context: runSwitch(host, args.port, statusFileName)
def main(): parser = argparse.ArgumentParser() parser.add_argument("--working-dir", default=os.getcwd(), help="working directory for the switch process") parser.add_argument("--private", action="store_true", help="Only accept local connections.") parser.add_argument("--port", type=int, default=0, help="listening port for switch") parser.add_argument("--statusfile", help="file to record status; useful for communications") parser.add_argument("--pidfile", help="file to record pid; useful for communciations") parser.add_argument("--unreliable", action="store_true", default=False, help="Introduce errors on the wire") parser.add_argument("--no-daemon", action="store_true", default=False, help="do not launch switch in a daemon; remain in foreground") args = parser.parse_args() workingDir = os.path.expanduser(os.path.expandvars(args.working_dir)) pidFileName = os.path.expanduser(os.path.expandvars(args.pidfile)) statusFileName = os.path.expanduser(os.path.expandvars(args.statusfile)) pidFileDir = os.path.dirname(pidFileName) host = None if args.private: host = "127.0.0.1" switch_type = "reliable" if args.unreliable: switch_type = "unreliable" if args.no_daemon: runSwitch(switch_type, host, args.port, statusFileName) else: with daemon.DaemonContext( working_directory=workingDir, umask=0o002, pidfile=pidfile.TimeoutPIDLockFile(pidFileName), ) as context: runSwitch(switch_type, host, args.port, statusFileName)
def main(): parser = argparse.ArgumentParser() parser.add_argument("vnic_address", help="Playground address of the VNIC") parser.add_argument("switch_address", help="IP address of the Playground Switch") parser.add_argument("switch_port", type=int, help="TCP port of the Playground Switch") parser.add_argument("--port", type=int, default=0, help="TCP port for serving VNIC connections") parser.add_argument( "--statusfile", help="file to record status; useful for communications") parser.add_argument("--pidfile", help="file to record pid; useful for communciations") args = parser.parse_args() pidFileName = os.path.expanduser(os.path.expandvars(args.pidfile)) statusFileName = os.path.expanduser(os.path.expandvars(args.statusfile)) pidFileDir = os.path.dirname(pidFileName) with daemon.DaemonContext( working_directory=pidFileDir, umask=0o002, pidfile=pidfile.TimeoutPIDLockFile(pidFileName), ) as context: runVnic(args.vnic_address, args.port, statusFileName, args.switch_address, args.switch_port)
def setUp(self): """ Set up test fixtures. """ self.mock_tracker = scaffold.MockTracker() pidlockfile_scenarios = make_pidlockfile_scenarios() self.pidlockfile_scenario = pidlockfile_scenarios['simple'] pidfile_path = self.pidlockfile_scenario['path'] scaffold.mock( "pidlockfile.PIDLockFile.__init__", tracker=self.mock_tracker) scaffold.mock( "pidlockfile.PIDLockFile.acquire", tracker=self.mock_tracker) self.scenario = { 'pidfile_path': self.pidlockfile_scenario['path'], 'acquire_timeout': object(), } self.test_kwargs = dict( path=self.scenario['pidfile_path'], acquire_timeout=self.scenario['acquire_timeout'], ) self.test_instance = pidlockfile.TimeoutPIDLockFile(**self.test_kwargs)
def serve(name, main): argv = FLAGS(sys.argv) if not FLAGS.pidfile: FLAGS.pidfile = '%s.pid' % name logging.debug("Full set of FLAGS: \n\n\n") for flag in FLAGS: logging.debug("%s : %s" % (flag, FLAGS.get(flag, None))) action = 'start' if len(argv) > 1: action = argv.pop() if action == 'stop': stop(FLAGS.pidfile) sys.exit() elif action == 'restart': stop(FLAGS.pidfile) elif action == 'start': pass else: print 'usage: %s [options] [start|stop|restart]' % argv[0] sys.exit(1) logging.getLogger('amqplib').setLevel(logging.WARN) if FLAGS.daemonize: logger = logging.getLogger() formatter = logging.Formatter(name + '(%(name)s): %(levelname)s %(message)s') if FLAGS.use_syslog and not FLAGS.logfile: syslog = logging.handlers.SysLogHandler(address='/dev/log') syslog.setFormatter(formatter) logger.addHandler(syslog) else: if not FLAGS.logfile: FLAGS.logfile = '%s.log' % name logfile = logging.handlers.FileHandler(FLAGS.logfile) logfile.setFormatter(formatter) logger.addHandler(logfile) stdin, stdout, stderr = None, None, None else: stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr if FLAGS.verbose: logging.getLogger().setLevel(logging.DEBUG) else: logging.getLogger().setLevel(logging.WARNING) with daemon.DaemonContext(detach_process=FLAGS.daemonize, working_directory=FLAGS.working_directory, pidfile=pidlockfile.TimeoutPIDLockFile( FLAGS.pidfile, acquire_timeout=1, threaded=False), stdin=stdin, stdout=stdout, stderr=stderr): main(argv)
def make_pidlockfile(path, acquire_timeout): """ Make a PIDLockFile instance with the given filesystem path. """ if not isinstance(path, basestring): error = ValueError("Not a filesystem path: %(path)r" % vars()) raise error if not os.path.isabs(path): error = ValueError("Not an absolute path: %(path)r" % vars()) raise error lockfile = pidlockfile.TimeoutPIDLockFile(path, acquire_timeout) return lockfile
def main(): parser = argparse.ArgumentParser(description='PTG bot.') parser.add_argument('configfile', help='specify the config file') parser.add_argument('-d', dest='nodaemon', action='store_true', help='do not run as a daemon') args = parser.parse_args() if not args.nodaemon: pid = pid_file_module.TimeoutPIDLockFile( "/var/run/ptgbot/ptgbot.pid", 10) with daemon.DaemonContext(pidfile=pid): start(args.configfile) start(args.configfile)
def main(): parser = argparse.ArgumentParser() parser.add_argument("vnic_address", help="Playground address of the VNIC") parser.add_argument("switch_address", help="IP address of the Playground Switch") parser.add_argument("switch_port", type=int, help="TCP port of the Playground Switch") parser.add_argument("--working-directory", default=os.getcwd(), help="working directory for vnic process") parser.add_argument("--port", type=int, default=0, help="TCP port for serving VNIC connections") parser.add_argument( "--statusfile", help="file to record status; useful for communications") parser.add_argument("--pidfile", help="file to record pid; useful for communciations") parser.add_argument( "--no-daemon", action="store_true", default=False, help="do not launch VNIC in a daemon; remain in foreground") args = parser.parse_args() workingDir = os.path.expanduser(os.path.expandvars(args.working_directory)) pidFileName = os.path.expanduser(os.path.expandvars(args.pidfile)) statusFileName = os.path.expanduser(os.path.expandvars(args.statusfile)) pidFileDir = os.path.dirname(pidFileName) if args.no_daemon: runVnic(args.vnic_address, args.port, statusFileName, args.switch_address, args.switch_port, False) else: with daemon.DaemonContext( working_directory=workingDir, umask=0o002, pidfile=pidfile.TimeoutPIDLockFile(pidFileName), ) as context: runVnic(args.vnic_address, args.port, statusFileName, args.switch_address, args.switch_port, True)
if app_data is None: print("Failed to mine amznMusic.appConfig", file=sys.stderr) logger.error("Failed to mine amznMusic.appConfig") sys.exit(1) logger.info( "Startup good, polling for new purchases every %d seconds." % pollInterval) if opts.daemonize: dcontext = daemon.DaemonContext() dcontext.files_preserve = [handler.stream] dcontext.umask = configuration['umask'] pidfile = configuration['daemonPidfile'].replace( '{username}', pwd.getpwuid(os.geteuid()).pw_name) dcontext.pidfile = pidlockfile.TimeoutPIDLockFile(pidfile) logger.info("Daemonizing...") try: with dcontext: functions.main_dl_loop(configuration, app_data, opts, session, pollInterval, logger) except pidlockfile.LockFailed as ex: # good chance we're detached from a tty at this point, but maybe print to stderr too anyway? logger.error("Could not acquire pidfile lock: " + ex.message) logger.error( "Check that you have permission to create and write to the pidfile, and that another instance is not already running." ) sys.exit(1) except Exception as ex:
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)