def start_RPC_server(host, port, rpc_path, rpc_proxy):
"""
Starts the RPC server and expose some methods of rpc_proxy
:param host:
:param port:
:param rpc_proxy:
:return:
"""
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
# default path was "RPC2"
rpc_paths = ('/' + rpc_path.lstrip('/'), )
logger = logging.getLogger(__name__)
logger.info('Starting RPC server on http://%s:%d%s ..', host, port, rpc_path)
server = SimpleXMLRPCServer((host, port), requestHandler=RequestHandler, allow_none=True)
server.register_introspection_functions()
server.register_instance(rpc_proxy)
try:
# Run the server's main loop
server.serve_forever()
except (KeyboardInterrupt, SystemExit):
logger.info("Server interrupted: Exiting!")
rpc_proxy.on_exit()
def main(argv=[__name__]):
if len(argv) < 2:
oechem.OEThrow.Usage(
"%s <server 1> <server 2> ... <server n> [portnumber=8080]" %
argv[0])
# default port number is 8080
portnumber = 8080
try:
portnumber = int(argv[-1])
servernames = argv[1:-1]
except ValueError:
servernames = argv[1:]
# Create server, an empty string is used to allow connections with
# any hostname
server = SimpleXMLRPCServer(("", portnumber),
requestHandler=RequestHandler)
server.register_introspection_functions()
server.register_instance(ShapeServerProxy(servernames))
try:
# Run the server's main loop
server.serve_forever()
finally:
server.server_close()
return 0
def run(self):
"""Run XMLRPC server, serving our methods."""
server = SimpleXMLRPCServer(("localhost", self.port))
self.server = server
server.register_instance(self)
self.queue.put(self.port)
server.serve_forever()
def start_xmlrpc_server():
"""
Initialize the XMLRPC thread
"""
def register_module(module):
for name, function in module.__dict__.items():
if hasattr(function, '__call__'):
server.register_function(function, name)
print("[+] Starting XMLRPC server: {}:{}".format(HOST, PORT))
server = SimpleXMLRPCServer((HOST, PORT),
requestHandler=ReqHandler,
logRequests=False,
allow_none=True)
# register ida python modules
register_module(idc)
register_module(idautils)
register_module(idaapi)
server.register_function(versions)
server.register_introspection_functions()
server.register_instance(PwnGef(server))
print("[+] Registered {} functions.".format(
len(server.system_listMethods())))
while True:
if hasattr(server, "shutdown") and server.shutdown is True:
break
server.handle_request()
return
class XMLRPCServer:
def __init__(self, path=None):
self.path = path
self.quit = False
def start(self, address='localhost', port=9000):
if self.path:
self.api = getAPI(self.path)
else:
self.api = class_api.getAPI()
self.server = SimpleXMLRPCServer((address, port), logRequests=False)
self.server.register_instance(self.api)
server_thread = threading.Thread(target=self._work_loop)
server_thread.start()
def _work_loop(self):
while not self.quit:
self.server.handle_request()
print 'Server exits'
self.api.stop()
def stop(self):
"""Stops the API"""
self.quit = True
def close(self):
"""Stops the API"""
self.quit = True
def cord_test_server_start(daemonize = True,
cord_test_host = CORD_TEST_HOST,
cord_test_port = CORD_TEST_PORT,
onos_cord = None,
foreground=False):
server = SimpleXMLRPCServer( (cord_test_host, cord_test_port) )
server.register_instance(CordTestServer())
CordTestServer.onos_cord = onos_cord
if daemonize is True:
##before daemonizing, preserve urandom needed by paramiko
preserve_list = find_files_by_path('/dev/urandom')
preserve_list.append(server)
d = daemon.DaemonContext(files_preserve = preserve_list,
detach_process = True)
with d:
reinitContainerClients()
server.serve_forever()
else:
if foreground:
try:
server.serve_forever()
except KeyboardInterrupt:
return server
else:
task = threading.Thread(target = server.serve_forever)
##terminate when main thread exits
task.daemon = True
task.start()
return server
class RPCServer(threading.Thread):
def __init__(self, serverIp, serverPort, rcpFuncInstance, logger=None):
super(RPCServer, self).__init__()
self.__serverIp = serverIp
self.__serverPort = serverPort
self.__rcpFuncInstance = rcpFuncInstance
self.__server = None
self.setName('http://%s:%d' % (self.__serverIp, self.__serverPort))
if logger is None:
self.logger = Logging.getLogger(Logging.LOGGER_NAME_DEFAULT)
else:
self.logger = logger
self.setDaemon(True)
def shutDownServer(self):
self.__server.shutdown()
self.__server.server_close()
def run(self):
from SimpleXMLRPCServer import SimpleXMLRPCServer
self.__server = SimpleXMLRPCServer(
(self.__serverIp, self.__serverPort), logRequests=False)
self.__server.register_instance(self.__rcpFuncInstance)
self.logger.info('RPC server started @ %s:%d', self.__serverIp,
self.__serverPort)
self.__server.serve_forever()
class Server(object):
def __init__(self, bind='localhost', port=22617, verbose=False):
self.server = None
self.bind = bind
self.port = port
self.verbose = verbose
self.s = linuxcnc.stat()
self.c = linuxcnc.command()
def s_poll(self):
self.s.poll()
ret = {}
#for attr in ['axis', 'axes', 'estop', 'enabled', 'homed', 'interp_state']:
# ret[attr] = getattr(self.s, attr)
# AttributeError: 'linuxcnc.stat' object has no attribute '__dict__'
'''
for k, v in self.s.__dict__.iteritems():
if k.startswith('_'):
continue
if not type(v) in [int, str]:
continue
'''
for k in ['axis', 'axes', 'estop', 'enabled', 'homed', 'interp_state']:
ret[k] = getattr(self.s, k)
# dict
ret['axis'] = self.s.axis
return ret
def constants(self):
ret = {}
for k, v in linuxcnc.__dict__.iteritems():
if k.startswith('_'):
continue
if not type(v) in [int, str]:
continue
ret[k] = v
return ret
def c_mdi(self, *args, **kwargs):
print 'mdi'
print args, kwargs
ret = self.c.mdi(*args, **kwargs)
print ret
def run(self):
print 'Starting server'
self.server = SimpleXMLRPCServer((self.bind, self.port), logRequests=self.verbose, allow_none=True)
self.server.register_introspection_functions()
self.server.register_multicall_functions()
self.server.register_instance(self)
self.server.register_function(self.c.mode, "c_mode")
self.server.register_function(self.c.wait_complete, "c_wait_complete")
#self.server.register_function(self.c.mdi, "c_mdi")
self.server.register_function(self.c_mdi, "c_mdi")
self.server.register_function(self.s.state, "s_state")
self.server.register_function(self.c.state, "c_state")
self.server.register_function(self.c.home, "c_home")
print 'Running'
self.server.serve_forever()
def serve(ip="localhost", port=8123):
server = SimpleXMLRPCServer((ip, port), allow_none=True)
server.register_introspection_functions()
server.register_instance(PandoraServerProxy())
t = eventlet.spawn(server.serve_forever)
t.wait()
def main():
"""Main."""
winutils.exit_if_admin()
script_name = os.path.basename(sys.argv[0]) # in case it is full path
script_name_no_ext = os.path.splitext(script_name)[0]
log_filename = "%s.log" % (script_name_no_ext, )
format = ("%(asctime)s %(name)s %(levelname)s : %(message)s")
logging.basicConfig(format=format,
filename=log_filename,
filemode='w',
level=logging.DEBUG)
print "Starting PTS ...",
pts = PyPTSWithXmlRpcCallback()
print "OK"
print "Serving on port {} ...".format(SERVER_PORT)
BaseHTTPServer.BaseHTTPRequestHandler.address_string = new_address_string
server = SimpleXMLRPCServer(("", SERVER_PORT), allow_none=True)
server.register_instance(pts)
server.register_introspection_functions()
server.serve_forever()
def xmlrpc_interface(self, bindaddr=('localhost',8001)):
'''
Method that create XML-RPC interface.
:param binaddr: tuple
'''
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
# Class RequestHandler : inherits from the base class SimpleXMLRPCRequestHandler
# For more details: http://docs.python.org/2/library/simplexmlrpcserver.html
# The SimpleXMLRPCServer module provides a basic server framework for XML-RPC servers written in Python.
# Create a new request handler instance. This request handler supports POST requests and modifies logging
# so that the logRequests parameter to the SimpleXMLRPCServer constructor parameter is honored.
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2',)
# Create server
server = SimpleXMLRPCServer(bindaddr,
requestHandler=RequestHandler)
# Registers the XML-RPC introspection functions system.listMethods, system.methodHelp and system.methodSignature.
server.register_introspection_functions()
# Register an instance; all the methods of the instance are
# published as XML-RPC methods
server.register_instance(waf_api())
try:
# Run the server's main loop
server.serve_forever()
except KeyboardInterrupt:
print "bye!"
return
def _start(self):
"""
start XML_RPC
"""
s = SimpleXMLRPCServer(("",getPort(self.url)),logRequests=False)
s.register_instance(self)
s.serve_forever()
def main():
addr = ("localhost", 5000) # 主机名, 端口
server = SimpleXMLRPCServer(addr) # 创建RPC服务.在指定端口,监听请求.
server.register_instance(StringFunction()) # 注册自定义的类
server.register_function(lambda a_str: "_" + a_str, name="_string") # 注册一个lambda函数,并命名为 _string()
print "server on..."
server.serve_forever() # 启动RPC服务,死循环.
def run(self):
"""Run forever on the configured port."""
s = SimpleXMLRPCServer(("0.0.0.0", self.port))
handler = Handler(self.queue)
s.register_instance(handler)
print "Starting XML RPC Handler."
s.serve_forever()
def main():
addr = ("localhost", 5000) # 主机名, 端口
server = SimpleXMLRPCServer(addr) # 创建RPC服务.在指定端口,监听请求.
server.register_instance(StringFunction()) # 注册自定义的类
server.register_function(lambda a_str: "_" + a_str, name="_string") # 注册一个lambda函数,并命名为 _string()
print "server on..."
server.serve_forever() # 启动RPC服务,死循环.
class XMLRPCServerThread(threading.Thread):
"""
Runs a SimpleXMLRPCServer in a new thread, so that the main
thread can watch for the heartbeats and kill the process if no
heartbeat messages arrive in time
:param port: the port where to listen to
:type port: int
"""
def __init__(self, port, debug):
threading.Thread.__init__(self)
self.port = port
self.daemon = True
self.debug = debug
def run(self):
self.server = SimpleXMLRPCServer(("localhost", port), allow_none=True, logRequests=False)
# enable debugging?
if self.debug:
sys.stderr.write("SublimePythonIDE Server is starting in Debug mode\n")
self.server.register_instance(DebuggingServer())
else:
self.server.register_instance(Server())
self.server.serve_forever()
def build_rpc_server_from_component(comp, service_name=None):
if service_name == None:
service_name = comp.__class__.__name__
server = SimpleXMLRPCServer(('', config.port[service_name]), allow_none=True)
server.register_instance(comp)
print "RPC Server started: %s:%d"%(comp.__class__.__name__, config.port[service_name])
return server
def _start(self):
"""
内部使用，用于启动XML_RPC服务器
"""
server = SimpleXMLRPCServer(("", getPort(self.url)), logRequests=False)
server.register_instance(self)
server.serve_forever()
class Server(object):
def __init__(self):
self.chan = Chan()
self._server = SimpleXMLRPCServer(
('0.0.0.0', SERVER_PORT),
logRequests=False,
allow_none=True)
self._server.register_introspection_functions()
self._server.register_instance(self)
self._thread = threading.Thread(name='Server', target=self._server.serve_forever)
self._thread.daemon = True
self._thread.start()
def status(self):
st = {'server': 'ok'}
try:
resp_chan = Chan(1)
self.chan.put(('status', resp_chan), timeout=0.5)
resp = resp_chan.get(timeout=0.5)
st.update(resp)
except Timeout:
st['loop'] = 'Error: Did not hear from main thread in time'
return st
def set_period(self, period):
self.chan.put(('set_period', period), timeout=2.0)
return True
def trip(self):
self.chan.put(('trip',), timeout=2.0)
return True
class SmellieServer:
'''
XML-RPC Protocol server that exposes a SmellieController to external
calls
'''
def __init__(self, address, port):
'''
Initialise the server on port and register functions
Calls: :func:`register <smellie_server.SmellieServer.register>
:param port: port
:param instance: controller object to expose to the server
'''
self.server = SimpleXMLRPCServer((address, port))
def serve_forever(self):
'''
Listen indefinitely for function calls to exectute
'''
self.server.serve_forever()
def register(self, instance):
'''
Register methods of instance with internal server, after wrapping with
:func:`exception_handler.str_wrap_exceptions` and :func:`dummy_mode.has_dummy_mode`
:param instance: controller object to expose to the server
'''
self.controller = instance
self.server.register_instance(wrap_all_methods(self.controller, [str_wrap_exceptions, has_dummy_mode]))
self.server.register_introspection_functions()
def start_listening(self):
findingport = True
while(findingport):
try:
server = SimpleXMLRPCServer(("localhost",
self.listenport),
allow_none=True,
logRequests=False)
findingport = False
except socket.error:
self.listenport += 1
self.reducecmds = ReduceCommands(self)
server.register_instance(self.reducecmds)
try:
while True:
r,w,x = select.select([server.socket], [],[],.5)
if r:
server.handle_request()
if self.finished == True:
break
except KeyboardInterrupt:
print '^C received, shutting down server'
server.socket.close()
return
def run(self):
port = SettingsBase.get_setting(self, "port")
self.__tracer.info("starting server on port %d", port)
if sys.version_info >= (2, 5):
xmlrpc_server = SimpleXMLRPCServer(
addr=('', port),
requestHandler=CustomXMLRPCRequestHandler,
logRequests=0,
allow_none=True)
else:
xmlrpc_server = SimpleXMLRPCServer(
addr=('', port),
requestHandler=CustomXMLRPCRequestHandler,
logRequests=0)
xmlrpc_server.register_introspection_functions()
xmlrpc_server.register_instance(XMLRPCAPI(self.__core))
try:
# Poll the stop event flag at a minimum of each second:
while not self.__stopevent.isSet():
rl, wl, xl = select([xmlrpc_server.socket], [], [], 1.0)
if xmlrpc_server.socket in rl:
xmlrpc_server.handle_request()
except:
self.__tracer.error("Exception occured during XMLRPC request:")
self.__tracer.debug(traceback.format_exc())
def main():
parser = argparse.ArgumentParser(description='EAFS Master Server')
parser.add_argument('--config', dest='config', default='/etc/eafs/master.cfg', help='Config file')
parser.add_argument('--host', dest='host', default='localhost', help='Bind to address')
parser.add_argument('--port', dest='port', default=6799, type=int, help='Bind to port')
parser.add_argument('--rootfs', dest='rootfs', default='/tmp', help='Save data to')
parser.add_argument('--backend', dest='backend', default='sqlite', help='Type of metadata backend')
parser.add_argument('--init', dest='init', default=0, type=int, help='Init DB: reset ALL meta data')
args = parser.parse_args()
config = ConfigParser.RawConfigParser()
config.read(args.config)
host = None
port = None
rootfs = None
backend = None
try:
host = config.get("Global", "host")
rootfs = config.get("Global", "rootfs")
backend = config.get("Global", "backend")
port = config.get("Global", "port")
except:
print "An error occured while reading config file"
if host is None: host = args.host
if port is None: port = args.port
if rootfs is None: rootfs = args.rootfs
if backend is None: backend = args.backend
# Create server
server = SimpleXMLRPCServer((host, port), requestHandler=RequestHandler, allow_none=True, logRequests=False)
server.register_introspection_functions()
server.register_instance(EAFSMaster(backend, rootfs, args.init))
server.serve_forever()
class CentralServer:
def __init__(self, ip, port, log=None):
# Node state
self.log = log
# Handler for the RPC requests
self.responder = ServerResponder(log)
# Accept incoming connections in a background thread
self.server = SimpleXMLRPCServer((ip,port),logRequests=False,bind_and_activate=False)
self.server.server_bind()
self.server.server_activate()
self.server.register_introspection_functions()
self.server.register_instance(self.responder)
t = Thread(target = self._run,name='{0}:{1}'.format(ip,port))
t.daemon = True
t.start()
log.blue('\n\nINIT - server')
log.blue('----------------')
self.log.blue( ip,port)
log.blue('----------------')
def _run(self):
""" Accept incoming connection till exit """
self.server.serve_forever()
class XMLRPCInterface(LoggingMixin):
def __init__(self, devide_app):
self._devide_app = devide_app
# initialise logging mixin
LoggingMixin.__init__(self)
print "Initialising XMLRPC..."
# without real IP number, this is only available via localhost
self.server = SimpleXMLRPCServer(('localhost', 8000))
self.server.register_instance(ServerProxy())
#server.register_function()
def handler_post_app_init(self):
"""DeVIDE-required method for interfaces."""
pass
def quit(self):
self.server.server_close()
def start_main_loop(self):
self.log_message('DeVIDE available at %s' % ('localhost:8000',))
self.log_message('Starting XMLRPC request loop.')
try:
self.server.serve_forever()
except KeyboardInterrupt:
self.log_message('Got keyboard interrupt.')
self.log_message('Shutting down.')
self.quit()
class XMLRPCInterface(object):
def __init__(self):
self.server = SimpleXMLRPCServer(conf.APISOCKNAME, requestHandler=SimpleXMLRPCRequestHandler, allow_none=True)
self.server.register_instance(TamahiyoCoreService())
self.server.register_introspection_functions() # テストの便利用、後で外す
self.rpc = xmlrpclib.ServerProxy(conf.APISERVER)
self.continue_ = threading.Event()
self.continue_.set()
self.update_at = 0
if os.path.exists(conf.UPDATE_TIMESTAMP):
with open(conf.UPDATE_TIMESTAMP, "r") as f:
self.update_at = float(f.read())
def thread_serve(self):
self.server.serve_forever()
print "thread_forever end"
def thread_daily_update(self):
while self.continue_.is_set():
time.sleep(1)
if day < time.time() - self.update_at:
t_start = time.time()
self.update_at = time.time()
self.rpc.daily_update()
with open(conf.UPDATE_TIMESTAMP, "w") as f:
f.write(str(self.update_at))
print "daily update", time.time() - t_start
print "thread_daily_update end"
def main():
model = gensim.models.word2vec.Word2Vec.load_word2vec_format(modelfile)
model.init_sims(replace=True)
s = SimpleXMLRPCServer(('0.0.0.0', 9001), allow_none=True)
s.register_instance(model, allow_dotted_names=True)
print s.server_address
s.serve_forever()
class RocServer(object):
def __init__(self, package_path, port, log_requests=True):
self.server = SimpleXMLRPCServer(("0.0.0.0", port),
allow_none=True,
logRequests=log_requests)
self.available_classes = dict(load_classes(package_path))
self.existing_instances = collections.defaultdict(lambda: [])
self.server.register_introspection_functions()
self.server.register_instance(self)
def shutdown(self):
threading.Thread(target=self.server.shutdown).start()
def classes(self):
return list(self.available_classes.keys())
def instances(self):
return list(itertools.chain(*self.existing_instances.values()))
def create(self, class_name, args=None):
if args is None:
args = []
instance = self.available_classes[class_name]['class'](*args)
instance_idx = len(self.existing_instances[class_name])
instance_name = '%s_%d' % (class_name, instance_idx)
for method_name in self.available_classes[class_name]['methods']:
bound_name = '.'.join([instance_name, method_name])
bound_method = getattr(instance, method_name)
self.server.register_function(bound_method, bound_name)
self.existing_instances[class_name].append(instance_name)
return instance_name
def server():
svr = SimpleXMLRPCServer((IP, PORT), allow_none=True)
svr.register_introspection_functions() # so that the client can do system.listMthods()
svr.register_multicall_functions() # so that the client can do multicall
svr.register_function(hello, name="default.hello") # specify the name so that the function can be grouped
svr.register_instance(Api(), allow_dotted_names=True) # only support one single instance
svr.serve_forever()
class XMLRPCServerThread(threading.Thread):
"""
Runs a SimpleXMLRPCServer in a new thread, so that the main
thread can watch for the heartbeats and kill the process if no
heartbeat messages arrive in time
:param port: the port where to listen to
:type port: int
"""
def __init__(self, port, debug):
threading.Thread.__init__(self)
self.port = port
self.daemon = True
self.debug = debug
def run(self):
self.server = SimpleXMLRPCServer(("localhost", port),
allow_none=True,
logRequests=False)
# enable debugging?
if self.debug:
sys.stderr.write(
"SublimePythonIDE Server is starting in Debug mode\n")
self.server.register_instance(DebuggingServer())
else:
self.server.register_instance(Server())
self.server.serve_forever()
class ServerThread(threading.Thread):
"""
Simple thread that encapsulates the running of the server that
hosts our Enso Extension's XML-RPC endpoint.
"""
def __init__( self, address ):
threading.Thread.__init__( self )
self._rpcServer = None
self._stop = False
self._address = address
def run( self ):
self._rpcServer = SimpleXMLRPCServer( self._address )
# We want to set the timeout so that we can CTRL-C out of the
# server on Windows machines. Windows won't let keyboard
# interrupts kick a process out of a socket system call, so we
# have to listen for incoming connections in 1-second
# "chunks".
self._rpcServer.socket.settimeout( 1.0 )
self._rpcServer.register_instance( EnsoExtensionMethods() )
while not self._stop:
self._rpcServer.handle_request()
def stop( self ):
self._stop = True
def main():
config = ConfigParser.RawConfigParser()
config.read('hass.conf')
log_level = logging.getLevelName(config.get("log", "level"))
log_file_name = config.get("log", "location")
dir = os.path.dirname(log_file_name)
if not os.path.exists(dir):
os.makedirs(dir)
logging.basicConfig(filename=log_file_name,
level=log_level,
format="%(asctime)s [%(levelname)s] : %(message)s")
server = SimpleXMLRPCServer(('', int(config.get("rpc", "rpc_bind_port"))),
requestHandler=RequestHandler,
allow_none=True,
logRequests=False)
server.register_introspection_functions()
server.register_multicall_functions()
HASS = Hass()
server.register_instance(HASS, allow_dotted_names=True)
rest_thread = HASS_RESTful.RESTfulThread(HASS)
rest_thread.daemon = True
rest_thread.start()
print "HASS Server ready"
try:
server.serve_forever()
except:
sys.exit(1)
def setup_server(server_root, hostname, port):
server = SimpleXMLRPCServer((hostname, port))
server.register_introspection_functions()
server.register_instance(PyBeatServer(server_root))
return server
def run(self):
port = SettingsBase.get_setting(self, "port")
self.__tracer.info("starting server on port %d", port)
if sys.version_info >= (2, 5):
xmlrpc_server = SimpleXMLRPCServer(
addr = ('', port),
requestHandler = CustomXMLRPCRequestHandler,
logRequests = 0,
allow_none = True)
else:
xmlrpc_server = SimpleXMLRPCServer(
addr = ('', port),
requestHandler = CustomXMLRPCRequestHandler,
logRequests = 0)
xmlrpc_server.register_introspection_functions()
xmlrpc_server.register_instance(XMLRPCAPI(self.__core))
try:
# Poll the stop event flag at a minimum of each second:
while not self.__stopevent.isSet():
rl, wl, xl = select([xmlrpc_server.socket], [], [], 1.0)
if xmlrpc_server.socket in rl:
xmlrpc_server.handle_request()
except:
self.__tracer.error("Exception occured during XMLRPC request:")
self.__tracer.debug(traceback.format_exc())
def make_server(host, port, instance):
#print "In make_server host: %s" % host
address = '%s:%s' % (host, port)
print "Listening on %s" % address
server = SimpleXMLRPCServer((host, port))
server.register_instance(instance)
return server
def start_RPC_server(host, port, rpc_path, rpc_proxy):
"""
Starts the RPC server and expose some methods of rpc_proxy
:param host:
:param port:
:param rpc_proxy:
:return:
"""
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
# default path was "RPC2"
rpc_paths = ('/' + rpc_path.lstrip('/'), )
logger = logging.getLogger(__name__)
logger.info('Starting RPC server on http://%s:%d%s ..', host, port,
rpc_path)
server = SimpleXMLRPCServer((host, port),
requestHandler=RequestHandler,
allow_none=True,
logRequests=False)
server.register_introspection_functions()
server.register_instance(rpc_proxy)
try:
# Run the server's main loop
server.serve_forever()
except (KeyboardInterrupt, SystemExit):
logger.info(
"RPC Server loop interrupted: Clean up and propagate SystemExit exception"
)
rpc_proxy.on_exit()
raise
def _start(self):
'''
start xml-rpc server
'''
s = SimpleXMLRPCServer(('', get_port(self.url)), logRequests=False)
s.register_instance(self)
s.serve_forever()
def main():
global logger, reactor
options, args = _parseCommandLine()
settings = localSettings()
if not options.debug:
sys.stdout = sys.stderr = LogFile(settings)
logger.setLevel(logging.INFO)
else:
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())
logging.getLogger("nitro.selectreactor").addHandler(logging.StreamHandler())
reactor = SelectReactor()
seedNodes = [(options.dhtnode, options.dhtport)]
service = CSpaceService(seedNodes, settings, reactor)
server = SimpleXMLRPCServer(("localhost", options.xmlport))
reactor.addReadCallback(server, server.handle_request)
server.register_instance(service, allow_dotted_names=True)
xmlrpcport = server.socket.getsockname()[1]
logger.info("rpcserver listenport = %i" % xmlrpcport)
appletport = service.appletServer.listenPort
logger.info("seed nodes = (%s:%i)" % (options.dhtnode, options.dhtport))
_writePID(xmlrpcport, appletport)
service.run()
_deletePID()
logger.info("server stopped.")
def RunServer(self, host='0.0.0.0', port=9992):
"""Runs Chameleon RPC server.
Args:
host: host address to serve the service.
port: port number of RPC server.
"""
caching = CachingServer(port + 1)
server = SimpleXMLRPCServer(
(host, port),
allow_none=True,
requestHandler=ChameleonXMLRPCRequestHandler,
logRequests=True)
server.register_introspection_functions()
# Setting allow_dotted_names=True allows a client to access the object
# members of self._driver. This is useful to group methods into
# different objects, e.g., audio, video, bluetooth hid, etc., in addition
# to some generic methods.
server.register_instance(self._driver, allow_dotted_names=True)
signal_handler = lambda signum, frame: sys.exit(0)
signal.signal(signal.SIGTERM, signal_handler)
try:
# Launch the caching server on the next port, serving cached files.
logging.info('Start the caching server process.')
caching.start()
# Launch the XMLRPC server to serve Chameleond APIs.
logging.info('Listening on %s port %d...', host, port)
server.serve_forever()
finally:
logging.info('Terminate the caching server process.')
caching.terminate()
def runServers():
"""Run python telnet server and info socket. They will be run at localhost on ports 9000 (or higher if used) and 21000 (or higer if used) respectively.
The python telnet server accepts only connection from localhost,
after authentication by random cookie, which is printed on stdout
at server startup.
The info socket provides read-only access to several simulation parameters
at runtime. Each connection receives pickled dictionary with those values.
This socket is primarily used by yade-multi batch scheduler.
"""
srv=GenericTCPServer(handler=yade.remote.PythonConsoleSocketEmulator,title='TCP python prompt',cookie=True,minPort=9000)
yade.runtime.cookie=srv.server.cookie
#info=GenericTCPServer(handler=yade.remote.InfoSocketProvider,title='TCP info provider',cookie=False,minPort=21000)
## XMPRPC server for general information:
if(sys.version_info[0]<3):
from SimpleXMLRPCServer import SimpleXMLRPCServer
else:
from xmlrpc.server import SimpleXMLRPCServer
port,maxPort=21000,65535 # minimum port number
while port<maxPort:
try:
info=SimpleXMLRPCServer(('',port),logRequests=False,allow_none=True); break
except socket.error: port+=1
if port==maxPort: raise RuntimeError("No free port to listen on in range 21000-%d"%maxPort)
# register methods, as per http://docs.python.org/library/simplexmlrpcserver.html#simplexmlrpcserver-example
info.register_instance(InfoProvider()) # gets all defined methods by introspection
#prov=InfoProvider()
#for m in prov.exposedMethods(): info.register_function(m)
_runInBackground(info.serve_forever)
print('XMLRPC info provider on http://localhost:%d'%port)
sys.stdout.flush()
def test():
server = SimpleXMLRPCServer(("", 17788), allow_none=True)
#server = SimpleXMLRPCServer(("10.10.10.200", 8000),allow_none=True)
server.register_introspection_functions()
server.register_instance(MessageHandler())
server.serve_forever()
input('should not be here ...')
def _start(self):
'''
start xml-rpc server
'''
s = SimpleXMLRPCServer(('', get_port(self.url)), logRequests=False)
s.register_instance(self)
s.serve_forever()
def setup_server(server_root, hostname, port):
server = SimpleXMLRPCServer((hostname, port))
server.register_introspection_functions()
server.register_instance(PyBeatServer(server_root))
return server
def run(self):
"""Run forever on the configured port."""
s=SimpleXMLRPCServer(("0.0.0.0", self.port))
handler=Handler(self.queue)
s.register_instance(handler)
print "Starting XML RPC Handler."
s.serve_forever()
def startRoombaInterface():
server = SimpleXMLRPCServer(('localhost', 9000), allow_none = True)
server.register_introspection_functions()
roomba = pyrobot.Roomba()
roomba.Control()
server.register_instance(roomba)
server.serve_forever()
def serve(ip="localhost", port=8123):
server = SimpleXMLRPCServer((ip, port), allow_none=True)
server.register_introspection_functions()
server.register_instance(PandoraServerProxy())
t = eventlet.spawn(server.serve_forever)
t.wait()
def runServers(xmlrpc=False,tcpPy=False):
"""Run python telnet server and info socket. They will be run at localhost on ports 9000 (or higher if used) and 21000 (or higer if used) respectively.
The python telnet server accepts only connection from localhost,
after authentication by random cookie, which is printed on stdout
at server startup.
The info socket provides read-only access to several simulation parameters
at runtime. Each connection receives pickled dictionary with those values.
This socket is primarily used by woo-multi batch scheduler.
"""
if tcpPy:
import woo.runtime
srv=GenericTCPServer(handler=woo.remote.PythonConsoleSocketEmulator,title='TCP python prompt',cookie=True,minPort=9000)
woo.runtime.cookie=srv.server.cookie
if xmlrpc:
from SimpleXMLRPCServer import SimpleXMLRPCServer
port,maxPort=21000,65535 # minimum port number
while port<maxPort:
try:
info=SimpleXMLRPCServer(('',port),logRequests=False,allow_none=True); break
except socket.error: port+=1
if port==maxPort: raise RuntimeError("No free port to listen on in range 21000-%d"%maxPort)
# register methods, as per http://docs.python.org/library/simplexmlrpcserver.html#simplexmlrpcserver-example
info.register_instance(InfoProvider()) # gets all defined methods by introspection
#prov=InfoProvider()
#for m in prov.exposedMethods(): info.register_function(m)
_runInBackground(info.serve_forever)
print 'XMLRPC info provider on http://localhost:%d'%port
sys.stdout.flush()
def run(self):
"""\
Body of XML-RPC presentation thread
This will be called as part of the execution of the Thread
portion of the XML-RPC presentation. Do not call this routine
manually.
"""
port = SettingsBase.get_setting(self, "port")
print "XMLRPC(%s): starting server on port %d" % \
(self.__name, port)
xmlrpc_server = SimpleXMLRPCServer(
addr=('', port),
requestHandler=CustomXMLRPCRequestHandler,
logRequests=0)
xmlrpc_server.register_introspection_functions()
xmlrpc_server.register_instance(XMLRPCAPI(self.__core))
try:
# Poll the stop event flag at a minimum of each second:
while not self.__stopevent.isSet():
rl, wl, xl = select([xmlrpc_server.socket], [], [], 1.0)
if xmlrpc_server.socket in rl:
xmlrpc_server.handle_request()
except:
print "Exception occured during XMLRPC request:"
print '-'*60
traceback.print_exc(file=sys.stdout)
print '-'*60
def test():
"""Integration testing.
TODO(tbroch) Enhance integration test and add unittest (see mox)
"""
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - ' + '%(levelname)s - %(message)s')
# configure server & listen
servod_obj = Servod(1)
# 5 == number of interfaces on a FT4232H device
for i in range(1, 5):
if i == 2:
# its an i2c interface ... see __init__ for details and TODO to make
# this configureable
servod_obj._interface_list[i].wr_rd(0x21, [0], 1)
else:
# its a gpio interface
servod_obj._interface_list[i].wr_rd(0)
server = SimpleXMLRPCServer(('localhost', 9999), allow_none=True)
server.register_introspection_functions()
server.register_multicall_functions()
server.register_instance(servod_obj)
logging.info('Listening on localhost port 9999')
server.serve_forever()
class RPCNativeBase(object):
def __init__(self, nativeObject, binderPort):
self.native = nativeObject
self.server = SimpleXMLRPCServer(('localhost', binderPort))
self.server.register_instance(self.native)
self.__backThread = GEVP.Pool(1)
def __runServer(self, name):
try:
print "Running " + name
self.__name = name
self.server.serve_forever()
except (KeyboardInterrupt):
self.server.server_close()
print "Receive KeyboardInterrupt in " + name
finally:
self.server.server_close()
def __del__(self):
self.stopNative()
# startNative will be blocked and wait
def startNative(self):
self.__backThread.spawn(self.__runServer, self.__class__.__name__)
def stopNative(self):
self.server.shutdown()
self.__backThread.join()
self.server.server_close()
print "Stopped " + self.__class__.__name__
def _start(self):
"""
Used internally to start the XML-RPC server.
"""
s = SimpleXMLRPCServer(("", getPort(self.url)), logRequests=False)
s.register_instance(self)
s.serve_forever()
def _start(self):
"""
internal function: to start XML-RPC server
"""
s = SimpleXMLRPCServer(("", getPort(self.url)), logRequests=False)
s.register_instance(self)
s.serve_forever()
def run(self):
"""Run XMLRPC server, serving our methods."""
server = SimpleXMLRPCServer(("0.0.0.0", self.port))
self.server = server
server.register_instance(self)
self.queue.put(self.port)
server.serve_forever()
def run(self):
peer = SimpleXMLRPCServer(("localhost", 8000 + self.nodeId), requestHandler = RequestHandler, allow_none = True)
print "Peer " + str(self.nodeId) + " is listening on port " + str(8000 + self.nodeId) + "..."
peer.register_introspection_functions()
self.new_peer = Peer(self.nodeId)
peer.register_instance(self.new_peer)
peer.serve_forever()
def _start(self):
"""
内部使用，用于启动XML_RPC服务器
"""
s = SimpleXMLRPCServer(("", getPort(self.url)), logRequests=False)
s.register_instance(self)
s.serve_forever()
def _start(self):
"""
Used internally to start the XML-RPC server.
"""
s = SimpleXMLRPCServer(('', getPort(self.url)), logRequests=False)
s.register_instance(self)
s.serve_forever()
def run(self):
"""Run server which returns an available server port where code
can be executed.
"""
server = SimpleXMLRPCServer(("localhost", self.my_port))
self.server = server
server.register_instance(self)
server.serve_forever()
