def start_sim_index_server(port, backends=(), remote_urls=(), root=True, logRequests=True): server = SimpleRPCServer(('localhost', port), logRequests=logRequests, requestHandler=RequestHandler) backend_list = list(backends) if remote_urls: backend_list.extend( [RemoteSimIndex(url) for url in remote_urls]) if backend_list: if len(backend_list) == 1: index = ConcurrentSimIndex(backend_list[0]) else: index = ConcurrentSimIndex( SimIndexCollection( shards=backend_list, root=root)) else: index = ConcurrentSimIndex(MemorySimIndex()) index.set_query_scorer('tfidf') server.register_instance(SimIndexService(index)) try: print('Use Control-C to exit') server.serve_forever() except KeyboardInterrupt: print('Exiting')
def start_sim_index_server(port, backends=(), remote_urls=(), root=True, logRequests=True): server = SimpleRPCServer(('localhost', port), logRequests=logRequests, requestHandler=RequestHandler) backend_list = list(backends) if remote_urls: backend_list.extend([RemoteSimIndex(url) for url in remote_urls]) if backend_list: if len(backend_list) == 1: index = ConcurrentSimIndex(backend_list[0]) else: index = ConcurrentSimIndex( SimIndexCollection(shards=backend_list, root=root)) else: index = ConcurrentSimIndex(MemorySimIndex()) index.set_query_scorer('tfidf') server.register_instance(SimIndexService(index)) try: print('Use Control-C to exit') server.serve_forever() except KeyboardInterrupt: print('Exiting')
def __init__(self, host, port): srv = SimpleJSONRPCServer((host, port)) srv.register_introspection_functions() srv.register_function(self.ping) mc = MissionCache() srv.register_instance(mc) print "[GameServerService] Up and running!" srv.serve_forever()
class JSONRPCapi(threading.Thread): def __init__(self, port): self.server = SimpleJSONRPCServer(('0.0.0.0', port), logRequests=False) self.server.register_instance(apiDispatcher) threading.Thread.__init__(self) def run(self): self.server.serve_forever() def register_function(self, *args, **kwargs): self.server.register_function(*args, **kwargs)
def __init__(self, host, port, testing=False, injector=None): srv = SimpleJSONRPCServer((host, port)) srv.register_introspection_functions() srv.register_function(self.ping) mc = EventServiceMethods() srv.register_instance(mc) if testing and injector is not None: injector.inject(mc) print "[GameServerService] Up and running!" srv.serve_forever()
class RPCProxyNode(BaseNode): def __init__(self, namespace, node_name, launch_params): super(RPCProxyNode, self).__init__(namespace, node_name, launch_params) self.server = SimpleJSONRPCServer((self.get_param('hostname', "0.0.0.0"), self.get_param('port', 8080))) self.server.register_instance(self) self.server.register_function(self.move_fwd) self.server.register_function(self.move_back) self.server.register_function(self.rotate_left) self.server.register_function(self.rotate_right) self.server.register_function(self.stop) self.server.register_function(self.slider_changed) self.server.register_function(self.enable_camera) self.server.register_function(self.disable_camera) self.server.register_function(self.talk) # def _dispatch(self, name, params): # self.message_bus.publish('/control/cmd', {'name': name, params: params}) def talk(self): self.message_bus.publish('/rpc/cmd', {'method': 'talk'}) # transform to talk def move_fwd(self): self.message_bus.publish('/rpc/cmd', {'method': 'move_fwd'}) def move_back(self): self.message_bus.publish('/rpc/cmd', {'method': 'move_back'}) def rotate_left(self): self.message_bus.publish('/rpc/cmd', {'method': 'rotate_left'}) def rotate_right(self): self.message_bus.publish('/rpc/cmd', {'method': 'rotate_right'}) def stop(self): self.message_bus.publish('/rpc/cmd', {'method': 'stop'}) def slider_changed(self, **kwargs): self.message_bus.publish('/rpc/cmd', {'method': 'slider_changed', 'value': kwargs['value']}) def enable_camera(self): self.message_bus.publish('/rpc/cmd', {'method': 'enable_camera'}) def disable_camera(self): self.message_bus.publish('/rpc/cmd', {'method': 'disable_camera'}) def run(self): self.server.serve_forever()
def server_set_up(addr, address_family=socket.AF_INET): # Not sure this is a good idea to spin up a new server thread # for each test... but it seems to work fine. def log_request(self, *args, **kwargs): """ Making the server output 'quiet' """ pass SimpleJSONRPCRequestHandler.log_request = log_request server = SimpleJSONRPCServer(addr, address_family=address_family) service = ExampleAggregateService() # Expose an instance of the service server.register_instance(service, allow_dotted_names=True) # Expose some aliases for service methods server.register_function(service.summation, 'sum') server.register_function(service.summation, 'notify_sum') server.register_function(service.summation, 'namespace.sum') server_proc = Thread(target=server.serve_forever) server_proc.daemon = True server_proc.start() return server_proc
def main(): server = SimpleJSONRPCServer(('', 8888)) server.register_instance(AudaciousProxy()) server.serve_forever()
out = [ '\n'.join((name, pformat(mock_.call_args_list))) for name, mock_ in mocker.mocks.items() ] return '\n'.join(out) else: out = [ name + ' ' + str(mock_.call_count) for name, mock_ in mocker.mocks.items() ] return '\n'.join(out) def givememoney(): import pdb pdb.set_trace() inst = ArithA() mocker.register_instance(inst) mocker.register_instance(ArithB()) mocker.unregister_instance(inst) mocker.register_instance(ArithA2()) mocker.register_function(printme) mocker.register_function(givememoney) server = SimpleJSONRPCServer(('localhost', 8080), logRequests=False) server.register_instance(mocker) print('Server listening on %s:%s' % server.socket.getsockname()) server.serve_forever()
return {"dirs":dirs,"files":files} def mfile(method,*args): t=[] for arg in args: if type(arg) in (str,unicode): p=arg.split('/') if p[0] in mediasources.keys(): t.append(mediasources[p[0]]+'/'.join(p[1:])) else: t.append(arg) try: return getattr(mp,method)(*t) except AttributeError: return "'%s' not found"%method ip = sys.argv[1] if len(sys.argv)>1 else "127.0.0.1" port = int(sys.argv[2]) if len(sys.argv)>2 else 1337 srv = SimpleJSONRPCServer((ip, port),MyRequestHandler) MPlayer.populate() mp = MPlayer() srv.register_instance(mp) srv.register_function(ls) srv.register_function(mfile) print "Starting Server on %s:%s"%(ip,port) srv.serve_forever()
open(config.get('General', 'bird6_dynamic_config'), 'w') open(config.get('General', 'bird6_dynamic_routes'), 'w') # Setup our server bind_info = None while not bind_info: try: bind_info = get_bind_info() except dns.resolver.Timeout: logging.warning("Timeout occured when retrieving settings from DNS.") except: logging.warning("Unknown error occured when retrieving settings from DNS.") if not bind_info: import time time.sleep(5) rpc_instance = RPC(bind_info) server = SimpleJSONRPCServer((rpc_instance.bind_ip, rpc_instance.bind_port), requestHandler = RequestHandler) server.register_instance(rpc_instance) # Start it up logging.info("Listening for requests.") import select while True: try: server.serve_forever() except select.error: # Just go along pass
class ArithB(object): def mul(self, a, b): return a * b def sub(self, x, y): return x - y def printme(verbose = False): if verbose: out = ['\n'.join((name, pformat(mock_.call_args_list))) for name, mock_ in mocker.mocks.items()] return '\n'.join(out) else: out = [name + ' ' + str(mock_.call_count) for name, mock_ in mocker.mocks.items()] return '\n'.join(out) def givememoney(): import pdb;pdb.set_trace() inst = ArithA() mocker.register_instance(inst) mocker.register_instance(ArithB()) mocker.unregister_instance(inst) mocker.register_instance(ArithA2()) mocker.register_function(printme) mocker.register_function(givememoney) server = SimpleJSONRPCServer(('localhost', 8080), logRequests=False) server.register_instance(mocker) print('Server listening on %s:%s' % server.socket.getsockname()) server.serve_forever()