os.chdir(os.path.dirname(os.path.abspath(__file__))) urls = (r'/', 'Index', r'/dashboard', 'Dashboard', r'/sensor', 'Sensor', r'/search', 'Search', r'/sensor_state', 'SensorState', r'/timeline', 'Timeline', r'/objsearch', 'ObjSearch', r'/obj', 'ObjViewer', r'/lastevents', 'LastEvents', r'/event', 'EventView', r'/hostobjects', 'HostObjects', r'/detects_data', 'JsonDetects', r'/detects', 'ViewDetects', r'/detect', 'ViewDetect') web.config.debug = False app = web.application(urls, globals()) render = web.template.render('templates', base='base', globals={ 'json': json, 'tsToTime': tsToTime }) if len(sys.argv) < 2: print("Usage: python app.py beach_config [listen_port]") sys.exit() beach = Beach(sys.argv[1], realm='hcp') del (sys.argv[1]) model = beach.getActorHandle('models', nRetries=3, timeout=30, ident='lc/0bf01f7e-62bd-4cc4-9fec-4c52e82eb903') app.run()
class BEAdmin(object): token = None def __init__(self, beach_config, token, timeout=1000 * 10): self.token = token self.beach = Beach(beach_config, realm='hcp') self.vHandle = self.beach.getActorHandle( 'c2/admin/1.0', ident='cli/955f6e63-9119-4ba6-a969-84b38bfbcc05', timeout=timeout, nRetries=3) def _query(self, cmd, data={}): data['token'] = self.token response = self.vHandle.request(cmd, data) return response def testConnection(self): return self._query('ping') def hcp_getAgentStates(self, aid=None, hostname=None): filters = {} if aid != None: filters['agent_id'] = aid if hostname != None: filters['hostname'] = hostname return self._query('hcp.get_agent_states', filters) def hcp_getEnrollmentRules(self): return self._query('hcp.get_enrollment_rules') def hcp_addEnrollmentRule(self, mask, externalIp, internalIp, newOrg, newSubnet, hostname): return self._query( 'hcp.add_enrollment_rule', { 'mask': mask, 'external_ip': externalIp, 'internal_ip': internalIp, 'new_org': newOrg, 'new_subnet': newSubnet, 'hostname': hostname }) def hcp_delEnrollmentRule(self, mask, externalIp, internalIp, hostname): return self._query( 'hcp.del_enrollment_rule', { 'mask': mask, 'external_ip': externalIp, 'internal_ip': internalIp, 'hostname': hostname }) def hcp_getTaskings(self): return self._query('hcp.get_taskings') def hcp_addTasking(self, mask, moduleId, hashStr): return self._query('hcp.add_tasking', { 'mask': mask, 'module_id': int(moduleId), 'hash': hashStr }) def hcp_delTasking(self, mask, moduleId, hashStr): return self._query('hcp.remove_tasking', { 'mask': mask, 'module_id': int(moduleId), 'hash': hashStr }) def hcp_getModules(self): return self._query('hcp.get_modules') def hcp_addModule(self, moduleId, binary, signature, description): return self._query( 'hcp.add_module', { 'module_id': moduleId, 'bin': binary, 'signature': signature, 'hash': hashlib.sha256(binary).hexdigest(), 'description': description }) def hcp_delModule(self, moduleId, hashStr): return self._query('hcp.remove_module', { 'module_id': moduleId, 'hash': hashStr }) def hcp_relocAgent(self, agentid, newOrg, newSubnet): return self._query('hcp.reloc_agent', { 'agentid': agentid, 'new_org': newOrg, 'new_subnet': newSubnet }) def hcp_getRelocations(self): return self._query('hcp.get_relocations') def hbs_getProfiles(self): return self._query('hbs.get_profiles') def hbs_addProfile(self, mask, config): return self._query('hbs.set_profile', { 'mask': mask, 'module_configs': config }) def hbs_delProfile(self, mask): return self._query('hbs.del_profile', {'mask': mask}) def hbs_taskAgent(self, toAgent, task, key, id, expiry=None, investigationId=None): # Make sure it's a valid agentid a = AgentId(toAgent) if not a.isValid: return None if not type(task) is rSequence: return None s = Signing(key) r = rpcm(isHumanReadable=True, isDebug=True) tags = Symbols() if investigationId is not None and '' != investigationId: task.addStringA(tags.hbs.INVESTIGATION_ID, investigationId) toSign = (rSequence().addSequence( tags.base.HCP_ID, rSequence().addInt8(tags.base.HCP_ID_ORG, a.org).addInt8( tags.base.HCP_ID_SUBNET, a.subnet).addInt32(tags.base.HCP_ID_UNIQUE, a.unique).addInt8( tags.base.HCP_ID_PLATFORM, a.platform).addInt8( tags.base.HCP_ID_CONFIG, a.config)).addSequence( tags.hbs.NOTIFICATION, task).addInt32(tags.hbs.NOTIFICATION_ID, id)) if None != expiry: toSign.addTimestamp(tags.base.EXPIRY, int(expiry)) toSign = r.serialise(toSign) sig = s.sign(toSign) final = r.serialise(rSequence().addBuffer( tags.base.BINARY, toSign).addBuffer(tags.base.SIGNATURE, sig)) return self._query('hbs.task_agent', { 'task': final, 'agentid': str(a), 'expiry': expiry })
class BEAdmin(object): token = None def __init__(self, beach_config, token, timeout=1000 * 10): self.token = token self.empty_uuid = uuid.UUID(bytes="\x00" * 16) self.beach = Beach(beach_config, realm='hcp') self.vHandle = self.beach.getActorHandle( 'c2/admin/1.0', ident='cli/955f6e63-9119-4ba6-a969-84b38bfbcc05', timeout=timeout, nRetries=3) def _query(self, cmd, data={}): data['token'] = self.token response = self.vHandle.request(cmd, data) return response def testConnection(self): return self._query('ping') def hcp_getAgentStates(self, aid=None, hostname=None): filters = {} if aid is not None: filters['aid'] = aid if hostname is not None: filters['hostname'] = hostname return self._query('hcp.get_agent_states', filters) def hcp_getTaskings(self, oid=None): return self._query('hcp.get_taskings', {'oid': oid}) def hcp_addTasking(self, mask, moduleId, hashStr): return self._query('hcp.add_tasking', { 'mask': mask, 'module_id': int(moduleId), 'hash': hashStr }) def hcp_delTasking(self, mask, moduleId): return self._query('hcp.remove_tasking', { 'mask': mask, 'module_id': int(moduleId) }) def hcp_getModules(self): return self._query('hcp.get_modules') def hcp_addModule(self, moduleId, binary, signature, description): return self._query( 'hcp.add_module', { 'module_id': moduleId, 'bin': binary, 'signature': signature, 'hash': hashlib.sha256(binary).hexdigest(), 'description': description }) def hcp_delModule(self, moduleId, hashStr): return self._query('hcp.remove_module', { 'module_id': moduleId, 'hash': hashStr }) def hcp_getInstallers(self, oid=None, iid=None, hash=None, withContent=False): return self._query('hcp.get_installers', { 'with_content': withContent, 'oid': oid, 'iid': iid, 'hash': hash }) def hcp_addInstaller(self, oid, iid, description, installer): return self._query( 'hcp.add_installer', { 'oid': oid, 'iid': iid, 'description': description, 'installer': installer }) def hcp_delInstaller(self, oid, iid, hash): return self._query('hcp.remove_installer', { 'oid': oid, 'iid': iid, 'hash': hash }) def hcp_getWhitelist(self, oid=None, iid=None): return self._query('hcp.get_whitelist', {'oid': oid, 'iid': iid}) def hcp_addWhitelist(self, oid, iid, bootstrap): return self._query('hcp.add_whitelist', { 'oid': oid, 'iid': iid, 'bootstrap': bootstrap }) def hcp_delWhitelist(self, oid, iid): return self._query('hcp.remove_whitelist', {'oid': oid, 'iid': iid}) def hbs_getProfiles(self, oid=[]): return self._query('hbs.get_profiles', {'oid': oid}) def hbs_addProfile(self, mask, config, tag): return self._query('hbs.set_profile', { 'mask': mask, 'module_configs': config, 'tag': tag }) def hbs_delProfile(self, mask): return self._query('hbs.del_profile', {'mask': mask}) def hbs_taskAgent(self, toAgent, task, key, id, expiry=None, investigationId=None): # Make sure it's a valid agentid a = AgentId(toAgent) if not type(task) is rSequence: return None s = Signing(key) r = rpcm(isHumanReadable=True, isDebug=True) tags = Symbols() if investigationId is not None and '' != investigationId: task.addStringA(tags.hbs.INVESTIGATION_ID, investigationId) toSign = (rSequence().addSequence( tags.base.HCP_IDENT, rSequence().addBuffer( tags.base.HCP_SENSOR_ID, (a.sensor_id if a.sensor_id is not None else self.empty_uuid).bytes).addBuffer( tags.base.HCP_ORG_ID, (a.org_id if a.org_id is not None else self.empty_uuid).bytes).addBuffer( tags.base.HCP_INSTALLER_ID, (a.ins_id if a.ins_id is not None else self.empty_uuid).bytes).addInt32( tags.base.HCP_ARCHITECTURE, a.architecture if a.architecture is not None else 0).addInt32( tags.base.HCP_PLATFORM, a.platform if a.platform is not None else 0)).addSequence( tags.hbs.NOTIFICATION, task).addInt32(tags.hbs.NOTIFICATION_ID, id)) if None != expiry: toSign.addTimestamp(tags.base.EXPIRY, int(expiry)) toSign = r.serialise(toSign) sig = s.sign(toSign) final = r.serialise(rSequence().addBuffer( tags.base.BINARY, toSign).addBuffer(tags.base.SIGNATURE, sig)) return self._query('hbs.task_agent', { 'task': final, 'aid': str(a), 'expiry': expiry }) def hbs_addKey(self, oid, key): return self._query('hbs.add_key', {'oid': oid, 'key': key})
r'/hostobjects', 'HostObjects', r'/detects_data', 'JsonDetects', r'/detects', 'ViewDetects', r'/detect', 'ViewDetect', r'/hostchanges', 'HostChanges' ) web.config.debug = False app = web.application( urls, globals() ) render = web.template.render( 'templates', base = 'base', globals = { 'json' : json, 'tsToTime' : tsToTime, '_x_' : _x_, '_xm_' : _xm_, 'hex' : hex, 'sanitize' : sanitizeJson } ) eventRender = web.template.render( 'templates/custom_events', globals = { 'json' : json, 'tsToTime' : tsToTime, '_x_' : _x_, '_xm_' : _xm_, 'hex' : hex, 'sanitize' : sanitizeJson } ) if len( sys.argv ) < 2: print( "Usage: python app.py beach_config [listen_port]" ) sys.exit() beach = Beach( sys.argv[ 1 ], realm = 'hcp' ) del( sys.argv[ 1 ] ) model = beach.getActorHandle( 'models', nRetries = 3, timeout = 30, ident = 'lc/0bf01f7e-62bd-4cc4-9fec-4c52e82eb903' ) app.run()
dest='source') parser.add_argument( '-i', '--ident', type=str, required=False, default='endpointproxy/8e7a890b-8016-4396-b012-aec73d055dd6', help='Beach identity to use to request list of endpoints.', dest='ident') parser.add_argument( '-u', '--update', type=int, required=False, default=60, help='refresh list of available endpoints every X seconds.', dest='update') arguments = parser.parse_args() currentEndpoints = Set() beach = Beach(arguments.config, realm='hcp') endpointActors = beach.getActorHandle('c2/endpoint', nRetries=3, timeout=30, ident=arguments.ident) updateEndpoints(endpointActors, arguments.update) proxy = LcEndpointProxy(arguments.source, currentEndpoints) proxy.start() gevent.wait()
class BEAdmin( object ): token = None def __init__( self, beach_config, token, timeout = 1000 * 10 ): self.token = token self.beach = Beach( beach_config, realm = 'hcp' ) self.vHandle = self.beach.getActorHandle( 'c2/admin/1.0', ident = 'cli/955f6e63-9119-4ba6-a969-84b38bfbcc05', timeout = timeout, nRetries = 3 ) def _query( self, cmd, data = {} ): data[ 'token' ] = self.token response = self.vHandle.request( cmd, data ) return response def testConnection( self ): return self._query( 'ping' ) def hcp_getAgentStates( self, aid = None, hostname = None ): filters = {} if aid != None: filters[ 'agent_id' ] = aid if hostname != None: filters[ 'hostname' ] = hostname return self._query( 'hcp.get_agent_states', filters ) def hcp_getPeriod( self ): return self._query( 'hcp.get_period' ) def hcp_setPeriod( self, period ): return self._query( 'hcp.set_period', { 'period' : int( period ) } ) def hcp_getEnrollmentRules( self ): return self._query( 'hcp.get_enrollment_rules' ) def hcp_addEnrollmentRule( self, mask, externalIp, internalIp, newOrg, newSubnet, hostname ): return self._query( 'hcp.add_enrollment_rule', { 'mask' : mask, 'external_ip' : externalIp, 'internal_ip' : internalIp, 'new_org' : newOrg, 'new_subnet' : newSubnet, 'hostname' : hostname } ) def hcp_delEnrollmentRule( self, mask, externalIp, internalIp, newOrg, newSubnet, hostname ): return self._query( 'hcp.del_enrollment_rule', { 'mask' : mask, 'external_ip' : externalIp, 'internal_ip' : internalIp, 'new_org' : newOrg, 'new_subnet' : newSubnet, 'hostname' : hostname } ) def hcp_getTaskings( self ): return self._query( 'hcp.get_taskings' ) def hcp_addTasking( self, mask, moduleId, hashStr ): return self._query( 'hcp.add_tasking', { 'mask' : mask, 'module_id' : int( moduleId ), 'hash' : hashStr } ) def hcp_delTasking( self, mask, moduleId, hashStr ): return self._query( 'hcp.remove_tasking', { 'mask' : mask, 'module_id' : int( moduleId ), 'hash' : hashStr } ) def hcp_getModules( self ): return self._query( 'hcp.get_modules' ) def hcp_addModule( self, moduleId, binary, signature, description ): return self._query( 'hcp.add_module', { 'module_id' : moduleId, 'bin' : binary, 'signature' : signature, 'hash' : hashlib.sha256( binary ).hexdigest(), 'description' : description } ) def hcp_delModule( self, moduleId, hashStr ): return self._query( 'hcp.remove_module', { 'module_id' : moduleId, 'hash' : hashStr } ) def hcp_relocAgent( self, agentid, newOrg, newSubnet ): return self._query( 'hcp.reloc_agent', { 'agentid' : agentid, 'new_org' : newOrg, 'new_subnet' : newSubnet } ) def hcp_getRelocations( self ): return self._query( 'hcp.get_relocations' ) def hbs_getPeriod( self ): return self._query( 'hbs.get_period' ) def hbs_setPeriod( self, period ): return self._query( 'hbs.set_period', { 'period' : int( period ) } ) def hbs_getProfiles( self ): return self._query( 'hbs.get_profiles' ) def hbs_addProfile( self, mask, config ): return self._query( 'hbs.set_profile', { 'mask' : mask, 'module_configs' : config } ) def hbs_delProfile( self, mask ): return self._query( 'hbs.del_profile', { 'mask' : mask } ) def hbs_taskAgent( self, toAgent, task, key, id, expiry = None, investigationId = None ): # Make sure it's a valid agentid a = AgentId( toAgent ) if not a.isValid: return None if not type( task ) is rSequence: return None s = Signing( key ) r = rpcm( isHumanReadable = True, isDebug = True ) tags = Symbols() if investigationId is not None and '' != investigationId: task.addStringA( tags.hbs.INVESTIGATION_ID, investigationId ) toSign = ( rSequence().addSequence( tags.base.HCP_ID, rSequence().addInt8( tags.base.HCP_ID_ORG, a.org ) .addInt8( tags.base.HCP_ID_SUBNET, a.subnet ) .addInt32( tags.base.HCP_ID_UNIQUE, a.unique ) .addInt8( tags.base.HCP_ID_PLATFORM, a.platform ) .addInt8( tags.base.HCP_ID_CONFIG, a.config ) ) .addSequence( tags.hbs.NOTIFICATION, task ) .addInt32( tags.hbs.NOTIFICATION_ID, id ) ) if None != expiry: toSign.addTimestamp( tags.base.EXPIRY, int( expiry ) ) toSign = r.serialise( toSign ) sig = s.sign( toSign ) final = r.serialise( rSequence().addBuffer( tags.base.BINARY, toSign ) .addBuffer( tags.base.SIGNATURE, sig ) ) return self._query( 'hbs.task_agent', { 'task' : final, 'agentid' : str( a ) } )
'public_ip': str( environment.get('X-FORWARDED-FOR', environment.get('REMOTE_ADDR', ''))) } resp = vHandle.request('beacon', data=clean_params) if resp.isSuccess: isSuccess = True response = '<html><h1>%s</h1></html>' % resp.data['resp'] if isSuccess: status = '200 OK' start_response(status, [('Content-Type', 'text/html'), ('Content-Length', str(len(response)))]) return [str(response)] beach = Beach(sys.argv[1], realm='hcp') vHandle = beach.getActorHandle( 'c2/beacon', nRetries=3, timeout=30, ident='http/5bc10821-2d3f-413a-81ee-30759b9f863b') server = wsgi.WSGIServer(('', 80), handle_beacon, spawn=100) server.serve_forever()
printFailure( "LC Web UI doesn't seem to be running, you can ignore this error if it is running from a different appliance.", isFatal=False) if 0 == os.system( 'ps -elf | grep -E ".*beach\\.dashboard.*" | grep -v grep > /dev/null' ): printSuccess('Beach dashboard is running.') else: printFailure( "Beach dashboard doesn't seem to be running, you can ignore this error if it is running from a different appliance.", isFatal=False) printStep('CORE ACTORS') allActors = BEACH.getActorHandle('', timeout=60) futures = allActors.requestFromAll('z', data={}) isSuccess = True nActors = 0 while not futures.isFinished(): if not futures.waitForResults(timeout=30): isSuccess = False break results = futures.getNewResults() for resp in results: handleActorResponse(resp) if not resp.isSuccess: isSuccess = False break nActors += 1 allActors.close()
print( "Creating ping actor in resource beach node." ) a1 = beach.addActor( 'Ping', 'pingers', strategy = 'resource' ) print( json.dumps( a1, indent = 4 ) ) print( "Creating pong actor in affinity( pingers ) beach node." ) a2 = beach.addActor( 'Pong', 'pongers', strategy = 'affinity', strategy_hint = 'pingers' ) print( json.dumps( a2, indent = 4 ) ) print( "Creating pong actor in isolation." ) a3 = beach.addActor( 'Pong', 'pongers', isIsolated = True ) print( json.dumps( a3, indent = 4 ) ) print( "Idling for a few seconds..." ) time.sleep( 15 ) print( "Querying for beach directory." ) d = beach.getDirectory() print( json.dumps( d, indent = 4 ) ) print( "Trying some queries to the cluster." ) vHandle = beach.getActorHandle( 'pongers' ) print( "Issuing ping" ) resp = vHandle.request( 'ping', data = { 'source' : 'outside' }, timeout = 10 ) print( "Received: %s" % str( resp ) ) time.sleep( 2 ) print( "Flushing beach." ) f = beach.flush() print( json.dumps( f, indent = 4 ) ) beach.close()
params = urlparse.parse_qs("".join(params).lstrip("&"), strict_parsing=True) except: params = {} if "pl" in params: clean_params = { "payload": params["pl"][0], "public_ip": str(environment.get("X-FORWARDED-FOR", environment.get("REMOTE_ADDR", ""))), } resp = vHandle.request("beacon", data=clean_params) if resp.isSuccess: isSuccess = True response = "<html><h1>%s</h1></html>" % resp.data["resp"] if isSuccess: status = "200 OK" start_response(status, [("Content-Type", "text/html"), ("Content-Length", str(len(response)))]) return [str(response)] beach = Beach(sys.argv[1], realm="hcp") vHandle = beach.getActorHandle("c2/beacon", nRetries=3, timeout=30, ident="http/5bc10821-2d3f-413a-81ee-30759b9f863b") server = wsgi.WSGIServer(("", 80), handle_beacon, spawn=100) server.serve_forever()
'msTsToTime': msTsToTime, '_x_': _x_, '_xm_': _xm_, 'hex': hex, 'sanitize': sanitizeJson, 'EventInterpreter': EventInterpreter, 'sorted': sorted }) if len(sys.argv) < 2: print("Usage: python app.py beach_config [listen_port]") sys.exit() beach = Beach(sys.argv[1], realm='hcp') del (sys.argv[1]) model = beach.getActorHandle('models', nRetries=3, timeout=30, ident='lc/0bf01f7e-62bd-4cc4-9fec-4c52e82eb903') capabilities = beach.getActorHandle( 'analytics/capabilitymanager', nRetries=3, timeout=60, ident='lc/0bf01f7e-62bd-4cc4-9fec-4c52e82eb903') sensordir = beach.getActorHandle( 'c2/sensordir', nRetries=3, timeout=30, ident='lc/0bf01f7e-62bd-4cc4-9fec-4c52e82eb903') app.run()
conf = userConf['config'] else: conf = args.config if conf is None: parser.error('no config specified and ~/.beach is not a valid config.') else: if args.req_realm is None and args.req_cat is None and args.req_cmd is None and args.req_ident is None: app = BeachShell(conf) app.cmdloop() elif args.req_realm is None or args.req_cat is None or args.req_cmd is None: parser.error('--req-* components missing to execute a request.') else: beach = Beach(conf, realm=args.req_realm) h = beach.getActorHandle(args.req_cat, ident=args.req_ident, timeout=args.req_timeout) if 0 == h.getNumAvailable(): h.close() beach.close() eprint("no actors available in category") sys.exit(1) if args.is_broadcast: futures = h.requestFromAll(args.req_cmd, data=args.req_data) else: resp = h.request(args.req_cmd, data=args.req_data) h.close() beach.close()
print("Creating pong actor in affinity( pingers ) beach node.") a2 = beach.addActor('Pong', 'pongers', strategy='affinity', strategy_hint='pingers') print(json.dumps(a2, indent=4)) print("Creating pong actor in isolation.") a3 = beach.addActor('Pong', 'pongers', isIsolated=True) print(json.dumps(a3, indent=4)) print("Idling for a few seconds...") time.sleep(15) print("Querying for beach directory.") d = beach.getDirectory() print(json.dumps(d, indent=4)) print("Trying some queries to the cluster.") vHandle = beach.getActorHandle('pongers') print("Issuing ping") resp = vHandle.request('ping', data={'source': 'outside'}, timeout=10) print("Received: %s" % str(resp)) time.sleep(2) print("Flushing beach.") f = beach.flush() print(json.dumps(f, indent=4)) beach.close()
renderFullPage = web.template.render( 'templates', base = 'base_full', globals = { 'json' : json, 'msTsToTime' : msTsToTime, '_x_' : _x_, '_xm_' : _xm_, 'hex' : hex, 'sanitize' : sanitizeJson, 'EventInterpreter' : EventInterpreter, 'md' : doMarkdown, 'sorted' : sorted, 'InvestigationNature' : InvestigationNature, 'InvestigationConclusion' : InvestigationConclusion } ) eventRender = web.template.render( 'templates/custom_events', globals = { 'json' : json, 'msTsToTime' : msTsToTime, '_x_' : _x_, '_xm_' : _xm_, 'hex' : hex, 'sanitize' : sanitizeJson, 'EventInterpreter' : EventInterpreter, 'sorted' : sorted } ) if len( sys.argv ) < 2: print( "Usage: python app.py beach_config [listen_port]" ) sys.exit() beach = Beach( sys.argv[ 1 ], realm = 'hcp' ) del( sys.argv[ 1 ] ) model = beach.getActorHandle( 'models', nRetries = 3, timeout = 30, ident = 'lc/0bf01f7e-62bd-4cc4-9fec-4c52e82eb903' ) capabilities = beach.getActorHandle( 'analytics/capabilitymanager', nRetries = 3, timeout = 60, ident = 'lc/0bf01f7e-62bd-4cc4-9fec-4c52e82eb903' ) sensordir = beach.getActorHandle( 'c2/sensordir', nRetries = 3, timeout = 30, ident = 'lc/0bf01f7e-62bd-4cc4-9fec-4c52e82eb903' ) app.run()
if not info.isSuccess: raiseUnavailable(str(info)) return info.data ############################################################################### # BOILER PLATE ############################################################################### os.chdir(os.path.dirname(os.path.abspath(__file__))) urls = (r'/', 'Index', r'/sensorstate', 'SensorState', r'/timeline', 'Timeline', r'/lastevents', 'LastEvents', r'/detects', 'Detects', r'/hostchanges', 'HostChanges', r'/objectloc', 'ObjectLocation') web.config.debug = False app = web.application(urls, globals()) if len(sys.argv) < 2: print("Usage: python app.py beach_config [listen_port]") sys.exit() beach = Beach(sys.argv[1], realm='hcp') del (sys.argv[1]) model = beach.getActorHandle('models', nRetries=3, timeout=30, ident='rest/be41bb0f-449a-45e9-87d8-ef4533336a2d') app.run()