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)
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 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()
