def test_setupEnvironment(self): """ L{UnixApplicationRunner.startApplication} calls L{UnixApplicationRunner.setupEnvironment} with the chroot, rundir, nodaemon, umask, and pidfile parameters from the configuration it is constructed with. """ options = twistd.ServerOptions() options.parseOptions([ '--nodaemon', '--umask', '0070', '--chroot', '/foo/chroot', '--rundir', '/foo/rundir', '--pidfile', '/foo/pidfile']) application = service.Application("test_setupEnvironment") self.runner = UnixApplicationRunner(options) args = [] def fakeSetupEnvironment(self, chroot, rundir, nodaemon, umask, pidfile): args.extend((chroot, rundir, nodaemon, umask, pidfile)) # Sanity check self.assertEqual( inspect.getargspec(self.runner.setupEnvironment), inspect.getargspec(fakeSetupEnvironment)) self.patch(UnixApplicationRunner, 'setupEnvironment', fakeSetupEnvironment) self.patch(UnixApplicationRunner, 'shedPrivileges', lambda *a, **kw: None) self.patch(app, 'startApplication', lambda *a, **kw: None) self.runner.startApplication(application) self.assertEqual( args, ['/foo/chroot', '/foo/rundir', True, 56, '/foo/pidfile'])
def test_removePIDErrors(self): """ Calling L{UnixApplicationRunner.removePID} with a non-existent filename logs an OSError. """ runner = UnixApplicationRunner({}) runner.removePID("fakepid") errors = self.flushLoggedErrors(OSError) self.assertEqual(len(errors), 1) self.assertEqual(errors[0].value.errno, errno.ENOENT)
def test_removePIDErrors(self): """ Calling L{UnixApplicationRunner.removePID} with a non-existent filename logs an OSError. """ runner = UnixApplicationRunner({}) runner.removePID("fakepid") errors = self.flushLoggedErrors(OSError) self.assertEquals(len(errors), 1) self.assertEquals(errors[0].value.errno, errno.ENOENT)
def setUp(self): self.root = self.unset self.cwd = self.unset self.mask = self.unset self.daemon = False self.pid = os.getpid() self.patch(os, 'chroot', lambda path: setattr(self, 'root', path)) self.patch(os, 'chdir', lambda path: setattr(self, 'cwd', path)) self.patch(os, 'umask', lambda mask: setattr(self, 'mask', mask)) self.patch(_twistd_unix, "daemonize", self.daemonize) self.runner = UnixApplicationRunner({})
def test_removePID(self): """ L{UnixApplicationRunner.removePID} deletes the file the name of which is passed to it. """ runner = UnixApplicationRunner({}) path = self.mktemp() os.makedirs(path) pidfile = os.path.join(path, "foo.pid") file(pidfile, "w").close() runner.removePID(pidfile) self.assertFalse(os.path.exists(pidfile))
def run(args): try: import threading main_thread = threading.current_thread().ident #logging.info("Starting Now") #print sys.argv config = ServerOptions() config.parseOptions() #app.runReactorWithLogging( # config, # sys.stdout, # sys.stderr, # TwistedFlameGraphProfiler(config['profile'], False), # None #) #runner = app.ApplicationRunner(config) #runner.profiler = TwistedFlameGraphProfiler("/tmp/twisted_flamegraph.log", False) #runner.startReactor(None, sys.stdout, sys.stderr ) #runner.run() sys.settrace(trace) threading.settrace(trace) UnixApplicationRunner(config).run() #app.run(args[0], ServerOptions) except Exception as e: print e.message finally: #while threading.active_count() > 1: # time.sleep(0.1) sys.settrace(None) threading.settrace(None) write_stats()
def runService(service): """Run the `service`.""" config = Options() args = [ '--logger=provisioningserver.logger.EventLogger', '--nodaemon', '--pidfile=', 'service=maas-rackd' ] args += sys.argv[1:] args += [service] try: config.parseOptions(args) except usage.error as exc: print(config) print("%s: %s" % (sys.argv[0], exc)) else: UnixApplicationRunner(config).run()
def runApp(config): UnixApplicationRunner(config).run()
class UnixApplicationRunnerSetupEnvironmentTests(unittest.TestCase): """ Tests for L{UnixApplicationRunner.setupEnvironment}. @ivar root: The root of the filesystem, or C{unset} if none has been specified with a call to L{os.chroot} (patched for this TestCase with L{UnixApplicationRunnerSetupEnvironmentTests.chroot ). @ivar cwd: The current working directory of the process, or C{unset} if none has been specified with a call to L{os.chdir} (patched for this TestCase with L{UnixApplicationRunnerSetupEnvironmentTests.chdir). @ivar mask: The current file creation mask of the process, or C{unset} if none has been specified with a call to L{os.umask} (patched for this TestCase with L{UnixApplicationRunnerSetupEnvironmentTests.umask). @ivar daemon: A boolean indicating whether daemonization has been performed by a call to L{_twistd_unix.daemonize} (patched for this TestCase with L{UnixApplicationRunnerSetupEnvironmentTests. """ if _twistd_unix is None: skip = "twistd unix not available" unset = object() def setUp(self): self.root = self.unset self.cwd = self.unset self.mask = self.unset self.daemon = False self.pid = os.getpid() self.patch(os, 'chroot', lambda path: setattr(self, 'root', path)) self.patch(os, 'chdir', lambda path: setattr(self, 'cwd', path)) self.patch(os, 'umask', lambda mask: setattr(self, 'mask', mask)) self.patch(_twistd_unix, "daemonize", self.daemonize) self.runner = UnixApplicationRunner({}) def daemonize(self): """ Indicate that daemonization has happened and change the PID so that the value written to the pidfile can be tested in the daemonization case. """ self.daemon = True self.patch(os, 'getpid', lambda: self.pid + 1) def test_chroot(self): """ L{UnixApplicationRunner.setupEnvironment} changes the root of the filesystem if passed a non-C{None} value for the C{chroot} parameter. """ self.runner.setupEnvironment("/foo/bar", ".", True, None, None) self.assertEqual(self.root, "/foo/bar") def test_noChroot(self): """ L{UnixApplicationRunner.setupEnvironment} does not change the root of the filesystem if passed C{None} for the C{chroot} parameter. """ self.runner.setupEnvironment(None, ".", True, None, None) self.assertIdentical(self.root, self.unset) def test_changeWorkingDirectory(self): """ L{UnixApplicationRunner.setupEnvironment} changes the working directory of the process to the path given for the C{rundir} parameter. """ self.runner.setupEnvironment(None, "/foo/bar", True, None, None) self.assertEqual(self.cwd, "/foo/bar") def test_daemonize(self): """ L{UnixApplicationRunner.setupEnvironment} daemonizes the process if C{False} is passed for the C{nodaemon} parameter. """ self.runner.setupEnvironment(None, ".", False, None, None) self.assertTrue(self.daemon) def test_noDaemonize(self): """ L{UnixApplicationRunner.setupEnvironment} does not daemonize the process if C{True} is passed for the C{nodaemon} parameter. """ self.runner.setupEnvironment(None, ".", True, None, None) self.assertFalse(self.daemon) def test_nonDaemonPIDFile(self): """ L{UnixApplicationRunner.setupEnvironment} writes the process's PID to the file specified by the C{pidfile} parameter. """ pidfile = self.mktemp() self.runner.setupEnvironment(None, ".", True, None, pidfile) fObj = file(pidfile) pid = int(fObj.read()) fObj.close() self.assertEqual(pid, self.pid) def test_daemonPIDFile(self): """ L{UnixApplicationRunner.setupEnvironment} writes the daemonized process's PID to the file specified by the C{pidfile} parameter if C{nodaemon} is C{False}. """ pidfile = self.mktemp() self.runner.setupEnvironment(None, ".", False, None, pidfile) fObj = file(pidfile) pid = int(fObj.read()) fObj.close() self.assertEqual(pid, self.pid + 1) def test_umask(self): """ L{UnixApplicationRunner.setupEnvironment} changes the process umask to the value specified by the C{umask} parameter. """ self.runner.setupEnvironment(None, ".", False, 123, None) self.assertEqual(self.mask, 123) def test_noDaemonizeNoUmask(self): """ L{UnixApplicationRunner.setupEnvironment} doesn't change the process umask if C{None} is passed for the C{umask} parameter and C{True} is passed for the C{nodaemon} parameter. """ self.runner.setupEnvironment(None, ".", True, None, None) self.assertIdentical(self.mask, self.unset) def test_daemonizedNoUmask(self): """ L{UnixApplicationRunner.setupEnvironment} changes the process umask to C{0077} if C{None} is passed for the C{umask} parameter and C{False} is passed for the C{nodaemon} parameter. """ self.runner.setupEnvironment(None, ".", False, None, None) self.assertEqual(self.mask, 0077)
def postApplication(self): self.createOpenvpn2DnsService() from twisted.internet import reactor deferLater(reactor, 1, self.zones.start_notify) UnixApplicationRunner.postApplication(self)
def __init__(self, config, twisted_config): UnixApplicationRunner.__init__(self, twisted_config) self.service_config = config
def runApp(config): runner = UnixApplicationRunner(config) runner.run() if runner._exitSignal is not None: app._exitWithSignal(runner._exitSignal)
def postApplication(self): reactor.callLater(0, self.start_globaleaks) UnixApplicationRunner.postApplication(self)