def test_once(timeout=6.0): with self.database.transaction(): self.assertIsNone(Initialized.lookupAny()) self.assertIsNone(Stopped.lookupAny()) ServiceManager.createOrUpdateService(WaitForService, svcName) ServiceManager.startService(svcName) ServiceManager.waitRunning(self.database, svcName, timeout=timeout) with self.database.view(): self.assertIsNotNone(Initialized.lookupAny()) with self.database.transaction(): ServiceManager.stopService(svcName) ServiceManager.waitStopped(self.database, svcName, timeout=timeout) with self.database.view(): self.assertIsNotNone(Stopped.lookupAny()) with self.database.transaction(): for obj in Initialized.lookupAll(): obj.delete() for obj in Stopped.lookupAll(): obj.delete()
def test_service_storage(self): with self.database.transaction(): ServiceManager.createOrUpdateService(StorageTest, "StorageTest", target_count=1) self.waitForCount(1)
def dialWorkers(self, workerCount): with self.database.transaction(): ServiceManager.createOrUpdateService(Task.TaskService, "TaskService", target_count=workerCount, gbRamUsed=0, coresUsed=0)
def test_starting_services(self): with self.database.transaction(): ServiceManager.createOrUpdateService(TestService, "TestService", target_count=1) self.waitForCount(1)
def deploy_helper(codebase_version, expected_version, existing_service=None): with self.database.transaction(): try: ServiceManager.createOrUpdateServiceWithCodebase( service_schema.Codebase.createFromFiles( getTestServiceModule(codebase_version)), "test_service.service.Service", serviceName, targetCount=1) except Exception: pass if existing_service: self.assertTrue( self.database.waitForCondition( lambda: not existing_service.connection.exists(), timeout=5.0)) self.waitForCount(1) with self.database.transaction(): s = TestServiceLastTimestamp.aliveServices()[0] self.assertEqual(s.version, expected_version) return s
def redeploy(database, config, watch=False): if watch: curHash = None while True: time.sleep(0.25) if curHash != hashCurrentCodebase(): print("Codebase changed to ", curHash, ". redeploying") try: redeploy(database, config) except Exception: print("ERROR: ") traceback.print_exc() curHash = hashCurrentCodebase() return with database.transaction(): ServiceManager.createOrUpdateService(ResearchFrontend, "ResearchFrontend", placement="Master") ServiceManager.createOrUpdateService(ResearchBackend, "ResearchBackend", placement="Master")
def __init__(self, ownHostname, host, port, sourceDir, storageDir, serviceToken, isMaster, maxGbRam=4, maxCores=4, logfileDirectory=None, shutdownTimeout=None, errorLogsOnly=False): self.host = host self.port = port self.storageDir = storageDir self.serviceToken = serviceToken self.logfileDirectory = logfileDirectory self.errorLogsOnly = errorLogsOnly self.lock = threading.Lock() if logfileDirectory is not None: if not os.path.exists(logfileDirectory): os.makedirs(logfileDirectory) if not os.path.exists(storageDir): os.makedirs(storageDir) if not os.path.exists(sourceDir): os.makedirs(sourceDir) def dbConnectionFactory(): return connect(host, port, self.serviceToken) ServiceManager.__init__( self, dbConnectionFactory, sourceDir, isMaster, ownHostname, maxGbRam=maxGbRam, maxCores=maxCores, shutdownTimeout=shutdownTimeout ) self.serviceProcesses = {} self._logger = logging.getLogger(__name__)
def test_logfiles_exist_and_get_recycled(self): with self.database.transaction(): ServiceManager.createOrUpdateService(TestService, "TestService", target_count=1) self.waitForCount(1) self.assertTrue( self.database.waitForCondition( lambda: len(os.listdir(self.logDir)) == 1, timeout=5.0, maxSleepTime=0.001)) priorFilename = os.listdir(self.logDir)[0] self.setCountAndBlock(0) self.setCountAndBlock(1) self.assertTrue( self.database.waitForCondition( lambda: len(os.listdir(self.logDir)) == 2, timeout=5.0, maxSleepTime=0.001)) newFilename = [x for x in os.listdir(self.logDir) if x != 'old'][0] self.assertNotEqual(priorFilename, newFilename)
def installServices(self): with self.database.transaction(): ServiceManager.createOrUpdateService(Task.TaskService, "TaskService", target_count=1, gbRamUsed=0, coresUsed=0) ServiceManager.createOrUpdateService(Task.TaskDispatchService, "TaskDispatchService", target_count=1, gbRamUsed=0, coresUsed=0) self.waitRunning("TaskService") self.waitRunning("TaskDispatchService") with open(os.path.join(ownDir, "test_files", "TestModule1.py"), "r") as f: files = {"TestModule1.py": f.read()} with self.database.transaction(): self.testService1Object = ServiceManager.createOrUpdateServiceWithCodebase( service_schema.Codebase.createFromFiles(files), "TestModule1.TestService1", "TestService1", 0) self.testService1Codebase = self.testService1Object.codebase.instantiate( ) self.service1Conn = self.newDbConnection() self.service1Conn.setSerializationContext( self.testService1Codebase.serializationContext) self.service1Conn.subscribeToType(Task.Task) self.service1Conn.subscribeToType(Task.TaskStatus) self.service1Conn.subscribeToType( self.testService1Codebase.getClassByName("TestModule1.Record"))
def configurableSetUp(self, auth_type="LDAP", auth_hostname=None, authorized_groups=(), ldap_base_dn=None, ldap_ntlm_domain=None, company_name=None): self.token = genToken() log_level = self._logger.getEffectiveLevel() loglevel_name = logging.getLevelName(log_level) self.server, self.cleanupFn = autoconfigure_and_start_service_manager( port=DATABASE_SERVER_PORT, auth_token=self.token, loglevel_name=loglevel_name) try: self.database = connect("localhost", DATABASE_SERVER_PORT, self.token, retry=True) self.database.subscribeToSchema(core_schema, service_schema, active_webservice_schema) with self.database.transaction(): service = ServiceManager.createOrUpdateService( ActiveWebService, "ActiveWebService", target_count=0) optional_args = [] if len(authorized_groups) > 0: optional_args.extend( ['--authorized-groups', *authorized_groups]) if auth_hostname: optional_args.extend(['--auth-hostname', auth_hostname]) if ldap_base_dn: optional_args.extend(['--ldap-base-dn', ldap_base_dn]) if ldap_ntlm_domain: optional_args.extend(['--ldap-ntlm-domain', ldap_ntlm_domain]) if company_name: optional_args.extend(['--company-name', company_name]) ActiveWebService.configureFromCommandline(self.database, service, [ '--port', str(WEB_SERVER_PORT), '--host', 'localhost', '--log-level', loglevel_name, '--auth', auth_type ] + optional_args) with self.database.transaction(): ServiceManager.startService("ActiveWebService", 1) self.waitUntilUp() except Exception: self.cleanupFn(error=True) raise
def configureResearchFrontend(database, config): with database.transaction(): frontend_svc = ServiceManager.createOrUpdateService(ResearchFrontend, "ResearchFrontend", placement="Master") ServiceManager.createOrUpdateService(ResearchBackend, "ResearchBackend", placement="Master")
def stop(self): self.stopAllServices(10.0) for instanceId, workers in self.serviceWorkers.items(): for worker in workers: worker.stop() self.serviceWorkers = {} ServiceManager.stop(self)
def __init__(self, dbConnectionFactory): self.storageRoot = tempfile.TemporaryDirectory() self.sourceRoot = tempfile.TemporaryDirectory() ServiceManager.__init__(self, dbConnectionFactory, self.sourceRoot.name, isMaster=True, ownHostname="localhost") self.serviceWorkers = {}
def test_service_restarts_after_killing(self): with self.database.transaction(): ServiceManager.createOrUpdateService(TestService, "TestService", target_count=1) self.waitForCount(1) with self.database.transaction(): s = TestServiceLastTimestamp.aliveServices()[0] s.triggerHardKill = True self.database.waitForCondition(lambda: not s.connection.exists(), timeout=5.0) self.waitForCount(1)
def stop(self, gracefully=True): if gracefully: self.stopAllServices(self.shutdownTimeout) ServiceManager.stop(self) with self.lock: for instanceIdentity, workerProcess in self.serviceProcesses.items(): workerProcess.terminate() for instanceIdentity, workerProcess in self.serviceProcesses.items(): workerProcess.wait() self.serviceProcesses = {}
def __init__(self, dbConnectionFactory, auth_token): self.storageRoot = tempfile.TemporaryDirectory() self.sourceRoot = tempfile.TemporaryDirectory() self.auth_token = auth_token setCodebaseInstantiationDirectory(self.sourceRoot.name) ServiceManager.__init__(self, dbConnectionFactory, self.sourceRoot.name, isMaster=True, ownHostname="localhost") self.serviceWorkers = {}
def test_own_ip_populated(self): with self.database.transaction(): ServiceManager.createOrUpdateService(TestService, "TestService", target_count=1) self.waitForCount(1) with self.database.view(): state = TestServiceLastTimestamp.lookupAny() # we should always know our ip as 127.0.0.1 because we infer it from # the server we connect to, and we connected to localhost. self.assertEqual(state.ownIp, "127.0.0.1")
def DISABLEDtest_throughput_with_many_workers(self): with self.database.transaction(): ServiceManager.createOrUpdateService(TestService, "TestService", target_count=0) throughputs = [] for ct in [16,18,20,22,24,26,28,30,32,34,0]: with self.database.transaction(): ServiceManager.startService("TestService", ct) self.waitForCount(ct) throughputs.append(self.measureThroughput(5.0)) print("Total throughput was", throughputs, " transactions per second")
def test_starting_uninitializable_services(self): with self.database.transaction(): svc = ServiceManager.createOrUpdateService(UninitializableService, "UninitializableService", target_count=1) self.assertTrue( self.database.waitForCondition( lambda: svc.timesBootedUnsuccessfully == ServiceInstance.MAX_BAD_BOOTS, 10 ) ) with self.database.view(): self.assertEqual(svc.effectiveTargetCount(), 0) with self.database.transaction(): svc.resetCounters() with self.database.view(): self.assertEqual(svc.effectiveTargetCount(), 1) self.assertTrue( self.database.waitForCondition( lambda: svc.timesBootedUnsuccessfully == ServiceInstance.MAX_BAD_BOOTS, 10 ) )
def test_shutdown_hanging_services(self): with self.database.transaction(): ServiceManager.createOrUpdateService(HangingService, "HangingService", target_count=10) self.waitForCount(10) t0 = time.time() with self.database.transaction(): ServiceManager.startService("HangingService", 0) self.waitForCount(0) self.assertTrue(time.time() - t0 < 2.0) # make sure we don't have a bunch of zombie processes hanging underneath the service manager time.sleep(1.0) self.assertEqual(len(psutil.Process().children()[0].children()), 0)
def test_redeploy_hanging_services(self): with self.database.transaction(): ServiceManager.createOrUpdateService(HangingService, "HangingService", target_count=10) self.waitForCount(10) with self.database.view(): instances = service_schema.ServiceInstance.lookupAll() orig_codebase = instances[0].codebase with self.database.transaction(): ServiceManager.createOrUpdateServiceWithCodebase( service_schema.Codebase.createFromFiles( getTestServiceModule(2)), "test_service.service.Service", "HangingService", 10) # this should force a redeploy. maxProcessesEver = 0 for i in range(40): maxProcessesEver = max( maxProcessesEver, len(psutil.Process().children()[0].children())) time.sleep(.1) self.database.flush() # after 2 seconds, we should be redeployed, but give Travis a bit more time if os.environ.get('TRAVIS_CI', None) is not None: time.sleep(10.0) with self.database.view(): instances_redeployed = service_schema.ServiceInstance.lookupAll() self.assertEqual(len(instances), 10) self.assertEqual(len(instances_redeployed), 10) self.assertEqual( len(set(instances).intersection(set(instances_redeployed))), 0) self.assertTrue(orig_codebase != instances_redeployed[0].codebase) # and we never became too big! self.assertLess(maxProcessesEver, 11)
def test_racheting_service_count_up_and_down(self): with self.database.transaction(): ServiceManager.createOrUpdateService(TestService, "TestService", target_count=1) numpy.random.seed(42) for count in numpy.random.choice(6, size=20): logging.getLogger(__name__).info( "Setting count for TestService to %s and waiting for it to be alive.", count) with self.database.transaction(): ServiceManager.startService("TestService", int(count)) self.waitForCount(count) with self.database.transaction(): ServiceManager.startService("TestService", 0) self.waitForCount(0) # make sure we don't have a bunch of zombie processes hanging underneath the service manager time.sleep(1.0) self.assertEqual(len(psutil.Process().children()[0].children()), 0)
def test_throughput_while_adjusting_servicecount(self): with self.database.transaction(): ServiceManager.createOrUpdateService(TestService, "TestService", target_count=0) emptyThroughputs = [self.measureThroughput(1.0)] fullThroughputs = [] for i in range(2): with self.database.transaction(): ServiceManager.startService("TestService", 20) self.waitForCount(20) fullThroughputs.append(self.measureThroughput(1.0)) with self.database.transaction(): ServiceManager.startService("TestService", 0) self.waitForCount(0) emptyThroughputs.append(self.measureThroughput(1.0)) print("Throughput with no workers: ", emptyThroughputs) print("Throughput with 20 workers: ", fullThroughputs) # we want to ensure that we don't have some problem where our transaction throughput # goes down because we have left-over connections or something similar in the server, # which would be a real problem! self.assertTrue(emptyThroughputs[-1] * 2 > emptyThroughputs[0], (emptyThroughputs))
def test_deploy_imported_module(self): with tempfile.TemporaryDirectory() as tf: for fname, contents in getTestServiceModule(1).items(): if not os.path.exists(os.path.join(tf, os.path.dirname(fname))): os.makedirs(os.path.join(tf, os.path.dirname(fname))) with open(os.path.join(tf, fname), "w") as f: f.write(contents) try: sys.path += [tf] test_service = __import__("test_service.service") with self.database.transaction(): ServiceManager.createOrUpdateService( test_service.service.Service, "TestService", target_count=1) self.waitForCount(1) finally: sys.path = [x for x in sys.path if x != tf]
def __init__(self, ownHostname, host, port, sourceDir, storageDir, authToken, isMaster, maxGbRam=4, maxCores=4, logfileDirectory=None, shutdownTimeout=None, logLevelName="INFO", metricUpdateInterval=2.0 ): self.cleanupLock = threading.Lock() self.host = host self.port = port self.storageDir = storageDir self.authToken = authToken self.logfileDirectory = logfileDirectory self.logLevelName = validateLogLevel(logLevelName, fallback='INFO') self.lock = threading.Lock() if logfileDirectory is not None: if not os.path.exists(logfileDirectory): os.makedirs(logfileDirectory) if not os.path.exists(storageDir): os.makedirs(storageDir) if not os.path.exists(sourceDir): os.makedirs(sourceDir) def dbConnectionFactory(): return connect(host, port, self.authToken) ServiceManager.__init__( self, dbConnectionFactory, sourceDir, isMaster, ownHostname, maxGbRam=maxGbRam, maxCores=maxCores, shutdownTimeout=shutdownTimeout, metricUpdateInterval=metricUpdateInterval ) self.serviceProcesses = {} self._logger = logging.getLogger(__name__)
def main(argv=None): if argv is not None: argv = sys.argv token = genToken() port = 8020 with tempfile.TemporaryDirectory() as tmpDirName: try: server = start_service_manager(tmpDirName, port, token) database = connect("localhost", port, token, retry=True) database.subscribeToSchema(core_schema, service_schema, active_webservice_schema) with database.transaction(): service = ServiceManager.createOrUpdateService( ActiveWebService, "ActiveWebService", target_count=0) ActiveWebService.configureFromCommandline(database, service, [ '--port', '8000', '--host', '0.0.0.0', '--auth', 'NONE', '--log-level', 'INFO' ]) with database.transaction(): ServiceManager.startService("ActiveWebService", 1) with database.transaction(): service = ServiceManager.createOrUpdateService( UninitializableService, "UninitializableService", target_count=1) with database.transaction(): service = ServiceManager.createOrUpdateService(HappyService, "HappyService", target_count=1) with database.transaction(): service = ServiceManager.createOrUpdateService( GraphDisplayService, "GraphDisplayService", target_count=1) while True: time.sleep(.1) finally: server.terminate() server.wait() return 0
def waitRunning(self, serviceName): self.assertTrue( ServiceManager.waitRunning(self.database, serviceName, self.WAIT_FOR_COUNT_TIMEOUT), "Service " + serviceName + " never came up.")
def main(argv=None): if argv is not None: argv = sys.argv token = genToken() port = 8020 loglevel_name = 'INFO' with tempfile.TemporaryDirectory() as tmpDirName: try: server = start_service_manager(tmpDirName, port, token, loglevel_name=loglevel_name) database = connect("localhost", port, token, retry=True) database.subscribeToSchema(core_schema, service_schema, active_webservice_schema) with database.transaction(): service = ServiceManager.createOrUpdateService( ActiveWebService, "ActiveWebService", target_count=0) ActiveWebService.configureFromCommandline( database, service, ['--port', '8000', '--host', '0.0.0.0', '--log-level', loglevel_name] ) ActiveWebService.setLoginPlugin( database, service, LoginIpPlugin, [None], config={'company_name': 'A Testing Company'} ) with database.transaction(): ServiceManager.startService("ActiveWebService", 1) with database.transaction(): service = ServiceManager.createOrUpdateService( UninitializableService, "UninitializableService", target_count=1 ) with database.transaction(): service = ServiceManager.createOrUpdateService( HappyService, "HappyService", target_count=1 ) with database.transaction(): service = ServiceManager.createOrUpdateService( GraphDisplayService, "GraphDisplayService", target_count=1 ) with database.transaction(): service = ServiceManager.createOrUpdateService( TextEditorService, "TextEditorService", target_count=1 ) with database.transaction(): service = ServiceManager.createOrUpdateService( DropdownTestService, "DropdownTestService", target_count=1 ) with database.transaction(): service = ServiceManager.createOrUpdateService( BigGridTestService, "BigGridTestService", target_count=1 ) with database.transaction(): ServiceManager.createOrUpdateServiceWithCodebase( service_schema.Codebase.createFromFiles({ 'test_service/__init__.py': '', 'test_service/service.py': textwrap.dedent(""" from object_database.service_manager.ServiceBase import ServiceBase class TestService(ServiceBase): gbRamUsed = 0 coresUsed = 0 def initialize(self): with self.db.transaction(): self.runtimeConfig.serviceInstance.statusMessage = "Loaded" def doWork(self, shouldStop): shouldStop.wait() def display(self, queryParams=None): return "test service display message" """) }), "test_service.service.TestService", "TestService", 10 ) print("SERVER IS BOOTED") while True: time.sleep(.1) finally: server.terminate() server.wait() return 0
def _main(argv): configureLogging() parser = argparse.ArgumentParser("Install and configure services.") parser.add_argument("--hostname", default=os.getenv("ODB_HOST", "localhost"), required=False) parser.add_argument("--port", type=int, default=int(os.getenv("ODB_PORT", 8000)), required=False) parser.add_argument("--auth", type=str, default=os.getenv("ODB_AUTH_TOKEN", ""), required=False, help="Auth token to use to connect.") subparsers = parser.add_subparsers() connections_parser = subparsers.add_parser('connections', help='list live connections') connections_parser.set_defaults(command='connections') install_parser = subparsers.add_parser('install', help='install a service') install_parser.set_defaults(command='install') install_parser.add_argument("--path", action='append', dest='paths') install_parser.add_argument("--class") install_parser.add_argument("--name", required=False) install_parser.add_argument("--placement", required=False, default='Any', choices=['Any','Master','Worker']) install_parser.add_argument("--singleton", required=False, action='store_true') reset_parser = subparsers.add_parser('reset', help='reset a service''s boot count') reset_parser.set_defaults(command='reset') reset_parser.add_argument("name") configure_parser = subparsers.add_parser('configure', help='configure a service') configure_parser.set_defaults(command='configure') configure_parser.add_argument("name") configure_parser.add_argument("args", nargs=argparse.REMAINDER) list_parser = subparsers.add_parser('list', help='list installed services') list_parser.set_defaults(command='list') instances_parser = subparsers.add_parser('instances', help='list running service instances') instances_parser.set_defaults(command='instances') hosts_parser = subparsers.add_parser('hosts', help='list running hosts') hosts_parser.set_defaults(command='hosts') start_parser = subparsers.add_parser('start', help='Start (or change target replicas for) a service') start_parser.set_defaults(command='start') start_parser.add_argument("name") start_parser.add_argument("--count", type=int, default=1, required=False) stop_parser = subparsers.add_parser('stop', help='Stop a service') stop_parser.set_defaults(command='stop') stop_parser.add_argument("name") parsedArgs = parser.parse_args(argv[1:]) db = connect(parsedArgs.hostname, parsedArgs.port, parsedArgs.auth) db.subscribeToSchema(core_schema, service_schema, lazySubscription=True) if parsedArgs.command == 'connections': table = [['Connection ID']] with db.view(): for c in sorted(core_schema.Connection.lookupAll(), key=lambda c: c._identity): table.append([c._identity]) print(formatTable(table)) if parsedArgs.command == 'configure': try: with db.transaction(): s = service_schema.Service.lookupAny(name=parsedArgs.name) svcClass = s.instantiateServiceType() svcClass.configureFromCommandline(db, s, parsedArgs.args) except Exception as e: traceback.print_exc() return 1 if parsedArgs.command == 'reset': with db.transaction(): service = service_schema.Service.lookupAny(name=parsedArgs.name) service.timesBootedUnsuccessfully = 0 if parsedArgs.command == 'install': if parsedArgs.paths: paths = parsedArgs.paths else: paths = [findGitParent(os.getcwd())] gbRamUsed = 1 coresUsed = 1 with db.transaction(): fullClassname = getattr(parsedArgs, 'class') modulename, classname = fullClassname.rsplit(".",1) if modulename.startswith("object_database"): def _getobject(modname, attribute): mod = __import__(modname, fromlist=[attribute]) return mod.__dict__[attribute] actualClass = _getobject(modulename, classname) if not isinstance(actualClass, type): print("Named class %s is not a type." % fullClassname) return 1 if not issubclass(actualClass, ServiceBase): print("Named class %s is not a ServiceBase subclass." % fullClassname) return 1 coresUsed = actualClass.coresUsed gbRamUsed = actualClass.gbRamUsed ServiceManager.createOrUpdateService(actualClass, classname, placement=parsedArgs.placement, isSingleton=parsedArgs.singleton, coresUsed=coresUsed, gbRamUsed=gbRamUsed ) else: codebase = service_schema.Codebase.create(paths) #make sure the codebase is importable, etc module = codebase.instantiate(modulename) if module is None: print("Can't find", module, "in the codebase") actualClass = module.__dict__.get(classname, None) if actualClass is None: print("Can't find", module, "in module", modulename) if actualClass is None: print("Can't find", classname, "in the codebase") return 1 if not isinstance(actualClass, type): print("Named class %s is not a type." % fullClassname) return 1 if not issubclass(actualClass, ServiceBase): print("Named class %s is not a ServiceBase subclass." % fullClassname) return 1 coresUsed = actualClass.coresUsed gbRamUsed = actualClass.gbRamUsed if not parsedArgs.name: name = fullClassname.split(".")[-1] else: name = parsedArgs.name ServiceManager.createOrUpdateServiceWithCodebase(codebase, fullClassname, name, targetCount=None, placement=parsedArgs.placement, coresUsed=coresUsed, gbRamUsed=gbRamUsed) if parsedArgs.command == 'list': table = [['Service', 'Codebase', 'Module', 'Class', 'Placement', 'TargetCount', 'Cores', 'RAM']] with db.view(): for s in sorted(service_schema.Service.lookupAll(), key=lambda s:s.name): table.append([ s.name, str(s.codebase), s.service_module_name, s.service_class_name, s.placement, str(s.target_count), s.coresUsed, s.gbRamUsed ]) print(formatTable(table)) if parsedArgs.command == 'instances': table = [['Service', 'Host', 'Connection', 'State']] with db.view(): for s in sorted(service_schema.ServiceInstance.lookupAll(), key=lambda s:(s.service.name, s.host.hostname, s.state)): table.append([ s.service.name, s.host.hostname, s.connection if s.connection.exists() else "<DEAD>", s.state ]) print(formatTable(table)) if parsedArgs.command == 'hosts': table = [['Connection', 'IsMaster', 'Hostname', 'RAM USAGE', 'CORE USAGE', 'SERVICE COUNT']] with db.view(): for s in sorted(service_schema.ServiceHost.lookupAll(), key=lambda s:s.hostname): table.append([ s.connection._identity, str(s.isMaster), s.hostname, "%.1f / %.1f" % (s.gbRamUsed, s.maxGbRam), "%s / %s" % (s.coresUsed, s.maxCores), str(len(service_schema.ServiceInstance.lookupAll(host=s))) ]) print(formatTable(table)) if parsedArgs.command == 'start': with db.transaction(): s = service_schema.Service.lookupAny(name=parsedArgs.name) if not s: print("Can't find a service named", s) return 1 s.target_count = max(parsedArgs.count, 0) if parsedArgs.command == 'stop': with db.transaction(): s = service_schema.Service.lookupAny(name=parsedArgs.name) if not s: print("Can't find a service named", s) return 1 s.target_count = 0 return 0
def configurableSetUp( self, hostname='localhost', login_plugin_factory=None, # default: LoginIpPlugin, login_config=None, auth_plugins=(None), module=None, db_init_fun=None): self.base_url = "http://{host}:{port}".format(host=hostname, port=WEB_SERVER_PORT) login_plugin_factory = login_plugin_factory or LoginIpPlugin self.token = genToken() log_level = self._logger.getEffectiveLevel() loglevel_name = logging.getLevelName(log_level) self.server, self.cleanupFn = autoconfigure_and_start_service_manager( port=DATABASE_SERVER_PORT, auth_token=self.token, loglevel_name=loglevel_name, own_hostname=hostname, db_hostname=hostname) try: self.database = connect(hostname, DATABASE_SERVER_PORT, self.token, retry=True) self.database.subscribeToSchema(core_schema, service_schema, active_webservice_schema) if db_init_fun is not None: db_init_fun(self.database) codebase = None if module is not None and not module.__name__.startswith( "object_database."): self.database.serializeFromModule(module) root_path = TypedPythonCodebase.rootlevelPathFromModule(module) tpcodebase = TypedPythonCodebase.FromRootlevelPath(root_path) with self.database.transaction(): codebase = service_schema.Codebase.createFromCodebase( tpcodebase) with self.database.transaction(): service = ServiceManager.createOrUpdateService( ActiveWebService, "ActiveWebService", target_count=0) ActiveWebService.configureFromCommandline(self.database, service, [ '--port', str(WEB_SERVER_PORT), '--host', hostname, '--log-level', loglevel_name, ]) if login_config is None: login_config = self.login_config ActiveWebService.setLoginPlugin(self.database, service, login_plugin_factory, auth_plugins, codebase=codebase, config=login_config) with self.database.transaction(): ServiceManager.startService("ActiveWebService", 1) self.waitUntilUp() except Exception: self.cleanupFn(error=True) raise