class NetServer(Thread):
def __init__(self, port=8080, logRequests=True):
Thread.__init__(self)
self.__port = port
self.__logRequests = logRequests
self.__server = None
self.__running = False
self.State = None
self.start()
while not self.__running:
sleep(0)
def stop(self):
if self.State is not None:
self.State.set_update_period(0)
self.__server.shutdown()
self.__server.server_close()
self.join()
def run(self):
#register API
self.State = NetServerState() # accessor for state object for tests and shutting down, etc
self.__server = SimpleXMLRPCServer(("127.0.0.1", self.__port), CrossDomainXMLRPCRequestHandler, logRequests=self.__logRequests)
self.__server.register_instance(self.State)
self.__server.register_introspection_functions()
#start server
self.__running = True
self.__server.serve_forever()
def start_server(obj):
"""
Purpose:
Start the XML-RPC server and register the "obj" class.
"""
try:
commandServer = SimpleXMLRPCServer(('', 9000), allow_none=True)
commandServer.register_introspection_functions()
commandServer.register_instance(obj)
print("{} - Starting to server forever".format(time.asctime()))
#Now keep the server alive till killed or system reboots
commandServer.serve_forever()
except KeyboardInterrupt as err:
print("{} - Keyboard Interrupt. Exiting.".format(time.asctime()))
return
except Exception as err:
print(err)
raise err
except System.Exception as err:
print(err)
raise err
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 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:
if future.utils.PY3: from xmlrpc.server import SimpleXMLRPCServer
else: 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()
class Server(threading.Thread):
"""
Thread for incoming messages (server side of the peer)
"""
def __init__(self, peer):
threading.Thread.__init__(self)
self.loop = True
self.peer = peer
try:
self.server = SimpleXMLRPCServer((peer.IPaddr, peer.portno), allow_none=True, logRequests = False) # we change this for not show unnecessary messages
self.server.register_instance(self.peer)
except Exception as e:
print(e)
sys.exit(0)
def log(self, *msg):
print("[%s]" % self.peer.name, *msg)
def stop(self):
self.server.server_close()
self.loop = False
def run(self):
while self.loop:
#self.log("xmlrpc server is handling a request...")
self.server.handle_request()
self.log("Server Done!")
def rpcserver():
server = SimpleXMLRPCServer(('localhost', 8000), requestHandler=TestRequestHandler)
server.register_introspection_functions()
server.register_function(pow)
server.register_function(adder_func, 'add')
server.register_instance(TestRPCClass())
server.serve_forever()
def run_xmlrpc_server():
port = 1210
oo_proxy = OOProxy()
#server = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", port))
server = SimpleXMLRPCServer(("localhost", port))
server.register_instance(oo_proxy)
#Go into the main listener loop
server.serve_forever()
def xmlsvr(self):
"""
Server xml-rpc thread el thread.
:return: void
"""
server = SimpleXMLRPCServer(("", self.port))
print("Listening on port %d..." % self.port)
server.register_instance(self)
server.serve_forever()
def start():
server = SimpleXMLRPCServer((HOST, PORT),
requestHandler=RequestHandler,
allow_none=True,
use_builtin_types=True)
server.register_instance(ServerHandler())
logging.info("Server is listening on " + HOST + ":" + str(PORT) + "/" +
ENDPOINT)
server.serve_forever()
def main():
server_address = ('localhost', 10000)
server = SimpleXMLRPCServer(server_address)
xmlrpc_service = CalcService()
server.register_instance(xmlrpc_service)
server.register_introspection_functions()
print("CTRL-C to stop")
server.serve_forever()
def test_exposeClass(self):
"""Expose an entire class and test the _dispatch method."""
server = SimpleXMLRPCServer((HOST, PORT + 3))
server.register_instance(MyService())
ServerThread(server).start()
# Access the exposed service.
client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 3))
self.assertEqual(client.squared(10), 100)
def serve_agent(agent: Agent, address: str, port: int) -> None:
"""Serve agent on specified bind address and port number."""
server = SimpleXMLRPCServer((address, port), allow_none=True)
server.register_instance(agent)
print('Listening on ', address, ':', port, sep="")
try:
server.serve_forever()
except KeyboardInterrupt:
pass
def run_server(strategy=Terminal(), port=49000):
"""Create the RPC server and share the entire strategy object."""
#hostname = socket.gethostname()
hostname = "0.0.0.0" # be greedy and listen on all local interfaces
IP = socket.gethostbyname(hostname)
server = SimpleXMLRPCServer((IP, port), allow_none=True, logRequests=False)
print("Listening on %s:%d" % (IP, port) )
server.register_instance(strategy)
server.serve_forever()
def test_exposeClass(self):
"""Expose an entire class and test the _dispatch method."""
server = SimpleXMLRPCServer((HOST, PORT + 3))
server.register_instance(MyService())
ServerThread(server).start()
# Access the exposed service.
client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 3))
self.assertEqual(client.squared(10), 100)
def start():
#NOTE: bots directory should always be on PYTHONPATH - otherwise it will not start.
#***command line arguments**************************
usage = '''
This is "%(name)s" version %(version)s, part of Bots open source edi translator (http://bots.sourceforge.net).
Server program that ensures only a single bots-engine runs at any time, and no engine run requests are
lost/discarded. Each request goes to a queue and is run in sequence when the previous run completes.
Use of the job queue is optional and must be configured in bots.ini (jobqueue section, enabled = True).
Usage:
%(name)s -c<directory>
Options:
-c<directory> directory for configuration files (default: config).
''' % {'name': os.path.basename(sys.argv[0]), 'version': 3.3}
configdir = 'config'
for arg in sys.argv[1:]:
if arg.startswith('-c'):
configdir = arg[2:]
if not configdir:
print('Error: configuration directory indicated, but no directory name.')
sys.exit(1)
else:
print(usage)
sys.exit(0)
#***end handling command line arguments**************************
#~ botsinit.generalinit(configdir) #find locating of bots, configfiles, init paths etc.
#~ if not botsglobal.ini.getboolean('jobqueue','enabled',False):
#~ print('Error: bots jobqueue cannot start; not enabled in %s/bots.ini'%(configdir))
#~ sys.exit(1)
nr_threads = 2 # botsglobal.ini.getint('jobqueue','nr_threads')
process_name = 'jobqueue'
#~ logger = botsinit.initserverlogging(process_name)
#~ logger.log(25,'Bots %(process_name)s started.',{'process_name':process_name})
#~ logger.log(25,'Bots %(process_name)s configdir: "%(configdir)s".',{'process_name':process_name,'configdir':botsglobal.ini.get('directories','config')})
port = 28082 # botsglobal.ini.getint('jobqueue','port',28082)
#~ logger.log(25,'Bots %(process_name)s listens for xmlrpc at port: "%(port)s".',{'process_name':process_name,'port':port})
#start launcher thread
lauchfrequency = 5 # botsglobal.ini.getint('jobqueue','lauchfrequency',5)
maxruntime = 60 # botsglobal.ini.getint('settings','maxruntime',60)
for thread in range(nr_threads)
launcher_thread = threading.Thread(name='launcher', target=launcher,
args=(logger, queue, lauchfrequency, maxruntime))
launcher_thread.start()
#~ logger.info('Jobqueue launcher started.')
#the main thread is the xmlrpc server: all adding, getting etc for jobqueue is done via xmlrpc.
#~ logger.info('Jobqueue server started.')
server = SimpleXMLRPCServer(('localhost', port), logRequests=False)
server.register_instance(Jobqueue(logger))
try:
server.serve_forever()
except KeyboardInterrupt:
pass
sys.exit(0)
def start(configdir):
"""Server program that ensures only a single bots-engine runs at any time,
and no engine run requests are lost/discarded.
Each request goes to a queue and is run in sequence when the previous run completes.
Use of the job queue is optional and must be configured in bots.ini (jobqueue section, enabled = True).
"""
botsinit.generalinit(configdir)
if not botsglobal.ini.getboolean('jobqueue', 'enabled', False):
print('Error: bots jobqueue cannot start; not enabled in {}/bots.ini'.
format(configdir))
sys.exit(1)
nr_threads = 2 # botsglobal.ini.getint('jobqueue','nr_threads')
process_name = 'jobqueue'
logger = botsinit.initserverlogging(process_name)
logger.log(25, 'Bots %(process_name)s started.',
{'process_name': process_name})
logger.log(
25, 'Bots %(process_name)s configdir: "%(configdir)s".', {
'process_name': process_name,
'configdir': botsglobal.ini.get('directories', 'config')
})
port = botsglobal.ini.getint('jobqueue', 'port', 28082)
logger.log(
25, 'Bots %(process_name)s listens for xmlrpc at port: "%(port)s".', {
'process_name': process_name,
'port': port
})
# start launcher thread
q = queue.Queue()
lauchfrequency = botsglobal.ini.getint('jobqueue', 'lauchfrequency', 5)
maxruntime = botsglobal.ini.getint('settings', 'maxruntime', 60)
for thread in range(nr_threads):
launcher_thread = threading.Thread(
name='launcher',
target=launcher,
args=(logger, q, lauchfrequency, maxruntime),
)
launcher_thread.start()
# the main thread is the xmlrpc server:
# all adding, getting etc for jobqueue is done via xmlrpc.
logger.info('Jobqueue server started.')
server = SimpleXMLRPCServer(('localhost', port), logRequests=False)
server.register_instance(Jobqueue(logger))
try:
server.serve_forever()
except (KeyboardInterrupt, SystemExit) as e: # noqa
pass
sys.exit(0)
class Server:
def __init__(self, name, port):
self.server = SimpleXMLRPCServer((name, port),
requestHandler=CARequestHandler)
self.server.register_introspection_functions()
self.server.register_instance(CentralAuthority(name))
def run(self):
# Run the server's main loop
self.server.serve_forever()
def main():
logging.basicConfig(filename='worker.log', level=logging.DEBUG, format='%(asctime)s %(levelname)s:%(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
print("Starting mapper connection..")
logging.info('Starting worker server connection.')
worker = Worker()
server = SimpleXMLRPCServer(("", 3389), allow_none=True)
server.register_instance(worker)
server.serve_forever()
def main():
# Create server
server = SimpleXMLRPCServer(("localhost", 9004),
requestHandler=RequestHandler)
server.register_introspection_functions()
server.register_instance(RegisteredFunctions())
# Run the server's main loop
server.serve_forever()
def serve_player(player, address, port):
"""Serve player on specified bind address and port number."""
from xmlrpc.server import SimpleXMLRPCServer
server = SimpleXMLRPCServer((address, port))
server.register_instance(player)
print("Listening on " + address + ":" + str(port))
try:
server.serve_forever()
except KeyboardInterrupt:
pass
def serve_agent(agent, address, port):
"""Serve agent on specified bind address and port number."""
from xmlrpc.server import SimpleXMLRPCServer
server = SimpleXMLRPCServer((address, port), allow_none=True)
server.register_instance(agent)
print("Listening on ", address, ":", port, sep="")
try:
server.serve_forever()
except KeyboardInterrupt:
pass
def serve_player(player, address, port):
"""Serve player on specified bind address and port number."""
from xmlrpc.server import SimpleXMLRPCServer
server = SimpleXMLRPCServer((address, port))
server.register_instance(player)
print("Listening on " + address + ":" + str(port))
try:
server.serve_forever()
except KeyboardInterrupt:
pass
def serve_agent(agent, address, port):
"""Serve agent on specified bind address and port number."""
from xmlrpc.server import SimpleXMLRPCServer
server = SimpleXMLRPCServer((address, port), allow_none=True)
server.register_instance(agent)
print("Listening on ", address, ":", port, sep="")
try:
server.serve_forever()
except KeyboardInterrupt:
pass
class RPCServer(threading.Thread):
"""
The RPCServer thread provides an API for external programs to interact
with MOM.
"""
def __init__(self, config, momFuncs):
threading.Thread.__init__(self, name="RPCServer")
self.setDaemon(True)
self.config = config
self.momFuncs = momFuncs
self.logger = logging.getLogger('mom.RPCServer')
self.server = None
self.start()
def thread_ok(self):
if self.server is None:
return True
return self.isAlive()
def create_server(self):
try:
unix_port = None
port = self.config.getint('main', 'rpc-port')
except ValueError:
port = None
unix_port = self.config.get('main', 'rpc-port')
self.logger.info("Using unix socket "+unix_port)
if unix_port is None and (port is None or port < 0):
return None
if unix_port:
self.server = UnixXmlRpcServer(unix_port)
else:
self.server = SimpleXMLRPCServer(("localhost", port),
requestHandler=RequestHandler, logRequests=0)
self.server.register_introspection_functions()
self.server.register_instance(self.momFuncs)
def shutdown(self):
if self.server is not None:
self.server.shutdown()
def run(self):
try:
self.create_server()
if self.server is not None:
self.logger.info("RPC Server starting")
self.server.serve_forever()
self.logger.info("RPC Server ending")
else:
self.logger.info("RPC Server is disabled")
except Exception as e:
self.logger.error("RPC Server crashed", exc_info=True)
def _start(self):
# Restrict to a particular path.
s = SimpleXMLRPCServer(("",self.port),requestHandler=RequestHandler)
s.register_instance(self)
s.register_introspection_functions()
s.serve_forever()
class ServerThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.localServer = SimpleXMLRPCServer((HOST, PORT),
requestHandler=RequestHandler,
allow_none=True)
self.localServer.register_introspection_functions()
self.localServer.register_instance(RemoteProcedures())
def run(self):
self.localServer.serve_forever()
def start_server(address, port):
server = SimpleXMLRPCServer((address, port))
server.register_instance(ServerAgent(), allow_dotted_names=True)
server.register_introspection_functions()
server.register_multicall_functions()
print('Serving XML-RPC on localhost port 8000')
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting. Shutting down server.")
sys.exit(0)
def _start(self):
s = SimpleXMLRPCServer(("", self.port),
requestHandler=RequestHandler,
logRequests=False)
s.register_instance(self)
# h = s.get_request()
# x = h[1]
s.register_introspection_functions()
print("server start....")
self.server = s
s.serve_forever()
def main(host, port, log_level, config):
app = CountingApp(config)
server = SimpleXMLRPCServer(('0', port), logRequests=True, allow_none=True)
server.register_introspection_functions()
server.register_instance(app)
try:
print('Use Control-C to exit')
server.serve_forever()
except KeyboardInterrupt:
print('Exiting...')
def run(self):
"""Starts the xmlrpc callback server"""
log("%s.%s", self.__class__.__name__, self.run.__name__)
log("Serving on port %s ...", self.port)
server = SimpleXMLRPCServer(("", self.port),
allow_none=True, logRequests=False)
server.register_instance(self.callback)
server.register_introspection_functions()
server.serve_forever()
def main(port, data):
# Create server
server = SimpleXMLRPCServer(('0.0.0.0', port),
requestHandler=RequestHandler,
use_builtin_types=True,
allow_none=True)
server.register_introspection_functions()
server.register_instance(LevelDB(data))
# Run the server's main loop
server.serve_forever()
def run_xmlrpc_server(host, port):
# build proxy
oo_proxy = OOProxy()
# start rpc server
server = SimpleXMLRPCServer((host, port))
server.register_instance(oo_proxy)
# listener loop
server.serve_forever()
return
class GutenTagServerThread(threading.Thread):
def __init__(self, gtdb):
threading.Thread.__init__(self)
self._gtdb = gtdb
self._server = SimpleXMLRPCServer(("localhost", gtag_common.RPC_PORT))
self._server.register_introspection_functions()
self._server.register_instance(self._gtdb)
def run(self):
self._gtdb.openDb()
self._server.serve_forever()
def main():
logging.basicConfig(format="%(asctime)s %(levelname)s "
"%(filename)s:%(lineno)d %(message)s")
LOG.setLevel(logging.INFO)
LOG.info("psutil version %s at %s", psutil.__version__, psutil.__file__)
server = SimpleXMLRPCServer(("0.0.0.0", 9002))
server.register_introspection_functions()
server.register_instance(MonHelperRPCInterface())
server.serve_forever()
def _start(self):
'''
Start the server part of client.
'''
global PORT
global ADDRESS
try:
server = SimpleXMLRPCServer((ADDRESS, PORT))
server.register_instance(self)
server.serve_forever()
except:
PORT += 1
self._start()
class RoboServer:
"""Cria a instancia do servidor responsavel pela comunicacao XML-RPC com o robo"""
def __init__(self, robo, ip, port):
self.robo = robo
self.ip = ip
self.port = int(port)
def start(self):
print("Starting XML-RPC Server...")
self.server = SimpleXMLRPCServer((self.ip, self.port), allow_none=True)
self.server.register_instance(self.robo)
print("Serving XML-RPC...")
self.server.serve_forever()
def main():
host = "localhost"
port = 7500
data_handler = DatabaseHandler()
try:
server = SimpleXMLRPCServer((host, port))
server.register_instance(data_handler)
server.serve_forever()
except KeyboardInterrupt:
print("Caught control-c, closing database connection")
data_handler.close()
def __init__(self):
super(ServerAgent, self).__init__()
logging.basicConfig(level=logging.DEBUG)
server = SimpleXMLRPCServer(('localhost', 9999), logRequests=True)
print("Listening on localhost:9999")
server.register_instance(self)
server.register_introspection_functions()
server.register_multicall_functions()
#server.serve_forever()
thread = threading.Thread(target=server.serve_forever)
thread.start()
print("Server thread started")
def all_systems_go():
dao = DAO(session())
instance = ClockServer(dao)
server = SimpleXMLRPCServer(("localhost", 8080),
requestHandler=RequestHandler,
logRequests=False,
allow_none=True)
server.register_introspection_functions()
server.register_instance(instance)
mainlog.info("The server is running")
server.serve_forever()
def _start(self):
'''
Start the server part of client.
'''
global PORT
global ADDRESS
try:
server = SimpleXMLRPCServer((ADDRESS, PORT))
server.register_instance(self)
server.serve_forever()
except:
PORT+=1
self._start()
class XmlRpcServer(object):
"""
XMLRPC service, exported functions are in class _RpcFuncs
"""
def __init__(self, host, port):
self._server = SimpleXMLRPCServer((host, port))
self._server.register_introspection_functions()
self._server.register_instance(_RpcFuncs())
logger.info('Listening for XMLRPC clients on %s:%d', host, port)
self._server.serve_forever()
def shutdown(self):
self._server.shutdown()
class RemoteController(metaclass=Singleton):
"""
Provide control over a SimpleXMLRPCServer.
"""
def __init__(self, ip='localhost', port=8070):
try:
self.server = SimpleXMLRPCServer((ip, port),
allow_none=True,
logRequests=False)
self._announcer = Announcer()
except OSError as error:
# If address already in use
if error.errno == 98:
raise Exception(
"Only one application instance can use this module")
else:
raise error
self.server.register_introspection_functions()
self.server.register_instance(RemoteDispatcher())
@async_function
def start(self):
logging.info('REMOTE: Session started at ' +
str(self.server.server_address))
self._announcer.start()
self.server.serve_forever() # Blocking
self._announcer.stop()
logging.info('REMOTE: Session ended')
def stop(self):
self.server.shutdown()
@staticmethod
def connect_to(uri):
proxy = ServerProxy(uri, transport=TimeoutTransport())
try:
# Call a fictive method.
proxy._()
except Fault:
# Connected, the method doesn't exist, which is expected.
pass
except socket.error:
# Not connected, socket error mean that the service is unreachable.
raise OSError('Session at ' + uri + ' is unreachable')
# Just in case the method is registered in the XmlRPC server
return proxy
class RemoteController(metaclass=Singleton):
"""
Provide control over a SimpleXMLRPCServer.
"""
def __init__(self, ip='localhost', port=8070):
try:
self.server = SimpleXMLRPCServer((ip, port), allow_none=True,
logRequests=False)
self._announcer = Announcer()
except OSError as error:
# If address already in use
if error.errno == 98:
raise Exception(
"Only one application instance can use this module")
else:
raise error
self.server.register_introspection_functions()
self.server.register_instance(RemoteDispatcher())
@async
def start(self):
logging.info('REMOTE: Session started at ' +
str(self.server.server_address))
self._announcer.start()
self.server.serve_forever() # Blocking
self._announcer.stop()
logging.info('REMOTE: Session ended')
def stop(self):
self.server.shutdown()
@staticmethod
def connect_to(uri):
proxy = ServerProxy(uri, transport=TimeoutTransport())
try:
# Call a fictive method.
proxy._()
except Fault:
# Connected, the method doesn't exist, which is expected.
pass
except socket.error:
# Not connected, socket error mean that the service is unreachable.
raise OSError('Session at ' + uri + ' is unreachable')
# Just in case the method is registered in the XmlRPC server
return proxy
def main():
opt = parse_cmdline()
logging.basicConfig(format="%(asctime)s %(levelname)s "
"%(filename)s:%(lineno)d %(message)s")
LOG.setLevel(logging.INFO)
LOG.info("psutil version %s at %s", psutil.__version__, psutil.__file__)
server = SimpleXMLRPCServer((opt.ip, opt.port))
LOG.info("listening at %s:%s", opt.ip, opt.port)
server.register_introspection_functions()
server.register_instance(MonHelperRPCInterface())
server.serve_forever()
def _start(self):
'''
Start the main server
'''
# Start the server.
try:
server = SimpleXMLRPCServer((gethostbyname(gethostname()),self.port))
server.register_instance(self)
print ('Start the main server successfully')
print('The URL of this server is '+gethostbyname(gethostname())+':'+str(self.port))
print('Copy this address to client.')
server.serve_forever()
except:
self.port+=1
self._start()
def startServer(box):
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2',)
# Create server
server = SimpleXMLRPCServer(("0.0.0.0", 8000),
requestHandler=RequestHandler, allow_none=True)
server.register_introspection_functions()
server.register_instance(box)
# Run the server's main loop
server.serve_forever()
def start_server(obj):
"""
Purpose:
Create the XML-RPC Server to allow CPython (and other tools) to interact with
the dksikuli instance and its Sikuli functions.
Similar to remotesrv.py's "start_server" function.
"""
guiServer = SimpleXMLRPCServer(('', 8080), allow_none=True)
guiServer.register_introspection_functions()
guiServer.register_instance(obj)
#Now keep the server alive till the end of the run
guiServer.serve_forever()
class TeacherProxy(object):
def __init__(self, teacher):
self._quit = False
self._teacher = teacher
self.server = SimpleXMLRPCServer(('0.0.0.0', 8080), logRequests=False, allow_none=True)
self.server.register_instance(self, allow_dotted_names=True)
Thread(target = self.run).start()
def run(self):
while not self._quit:
self.server.handle_request()
def add_winner(self, winner_uuid):
self._teacher.add_winner(winner_uuid)
def start(configdir):
"""Server program that ensures only a single bots-engine runs at any time,
and no engine run requests are lost/discarded.
Each request goes to a queue and is run in sequence when the previous run completes.
Use of the job queue is optional and must be configured in bots.ini (jobqueue section, enabled = True).
"""
botsinit.generalinit(configdir)
if not botsglobal.ini.getboolean('jobqueue', 'enabled', False):
print('Error: bots jobqueue cannot start; not enabled in {}/bots.ini'.format(configdir))
sys.exit(1)
nr_threads = 2 # botsglobal.ini.getint('jobqueue','nr_threads')
process_name = 'jobqueue'
logger = botsinit.initserverlogging(process_name)
logger.log(25, 'Bots %(process_name)s started.', {'process_name': process_name})
logger.log(25, 'Bots %(process_name)s configdir: "%(configdir)s".', {
'process_name': process_name, 'configdir': botsglobal.ini.get('directories', 'config')})
port = botsglobal.ini.getint('jobqueue', 'port', 28082)
logger.log(25, 'Bots %(process_name)s listens for xmlrpc at port: "%(port)s".',
{'process_name': process_name, 'port': port})
# start launcher thread
q = queue.Queue()
lauchfrequency = botsglobal.ini.getint('jobqueue', 'lauchfrequency', 5)
maxruntime = botsglobal.ini.getint('settings', 'maxruntime', 60)
for thread in range(nr_threads):
launcher_thread = threading.Thread(
name='launcher',
target=launcher,
args=(logger, q, lauchfrequency, maxruntime),
)
launcher_thread.start()
# the main thread is the xmlrpc server:
# all adding, getting etc for jobqueue is done via xmlrpc.
logger.info('Jobqueue server started.')
server = SimpleXMLRPCServer(('localhost', port), logRequests=False)
server.register_instance(Jobqueue(logger))
try:
server.serve_forever()
except (KeyboardInterrupt, SystemExit) as e: # noqa
pass
sys.exit(0)
def start_server(self):
"""
Purpose:
Start the XML-RPC server and register the "postrun" class.
"""
servicemanager.LogInfoMsg("Running in 'start_server'")
postrunObj = postrun()
commandServer = SimpleXMLRPCServer(("localhost", 9000), allow_none=True)
commandServer.register_introspection_functions()
commandServer.register_instance(postrunObj)
#Now keep the server alive till the end of the run
guiServer.serve_forever()
class RemoteController(Thread, metaclass=Singleton):
def __init__(self, ip='localhost', port=8070):
super().__init__(daemon=True)
self.setName('RemoteController')
self.server = SimpleXMLRPCServer((ip, port), allow_none=True,
logRequests=False)
self.server.register_introspection_functions()
self.server.register_instance(RemoteDispatcher())
self._announcer = Announcer()
def start(self):
self._announcer.start()
Thread.start(self)
def run(self):
logging.info('REMOTE: Session started at ' +
str(self.server.server_address))
self.server.serve_forever()
logging.info('REMOTE: Session ended')
def stop(self):
self.server.shutdown()
self._announcer.stop()
@staticmethod
def connect_to(uri):
proxy = ServerProxy(uri, transport=TimeoutTransport())
try:
# Call a fictive method.
proxy._()
except Fault:
# Connected, the method doesn't exist, which is expected.
pass
except socket.error:
# Not connected, socket error mean that the service is unreachable.
raise Exception('Session at ' + uri + ' is unreachable')
# Just in case the method is registered in the XmlRPC server
return proxy
def main():
autoWait()
ea = ScreenEA()
server = SimpleXMLRPCServer(("localhost", 9000))
server.register_function(is_connected, "is_connected")
server.register_function(wrapper_get_raw, "get_raw")
server.register_function(wrapper_get_function, "get_function")
server.register_function(wrapper_Heads, "Heads")
server.register_function(wrapper_Functions, "Functions")
server.register_instance(IDAWrapper())
server.register_function(wrapper_quit, "quit")
server.serve_forever()
qexit(0)
class PilotwireServer:
def __init__(self, port, debug, controller_name):
self.xmlrpc_server = SimpleXMLRPCServer(('', port), logRequests=debug)
manager = DriverManager(
namespace='pilotwire.controller',
name=controller_name,
invoke_on_load=True,
)
self.controller = manager.driver
self.xmlrpc_server.register_instance(XMLRPCMethods(self.controller))
def start(self):
self.xmlrpc_server.serve_forever()
def stop(self):
self.xmlrpc_server.shutdown()
self.xmlrpc_server.server_close()
def main(args=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--address', '-a', default='0.0.0.0', help='the '
'address on which the server is listening (e.g., '
'"127.0.0.1", default "0.0.0.0").')
parser.add_argument('--port', '-p', type=int, default=9002, help='the port'
' on which the server is listening (default "9002").')
args = parser.parse_args(args)
logging.basicConfig(format="%(asctime)s %(levelname)s "
"%(filename)s:%(lineno)d %(message)s")
LOG.setLevel(logging.INFO)
LOG.info("psutil version %s at %s", psutil.__version__, psutil.__file__)
server = SimpleXMLRPCServer((args.address, args.port))
LOG.info("serving on %s:%d", args.address, args.port)
server.register_introspection_functions()
server.register_instance(MonHelperRPCInterface())
server.serve_forever()
class TableProxy(object):
def __init__(self, table):
self._table = table
self.server = SimpleXMLRPCServer(('0.0.0.0', 8000), logRequests=False, allow_none=True)
self.server.register_instance(self, allow_dotted_names=True)
Thread(target=self.server.serve_forever).start()
def get_table_state(self, playerID):
return self._table.output_state(table._player_dict.get(playerID, None))
def add_player(self, host, port, playerID, name, stack):
self._table.add_player(host, port, playerID, name, stack)
def remove_player(self, playerID):
self._table.remove_player(playerID)
def run_game(self):
self._table.run_game()
def run_forever(self):
self._table.start()
class PlayerControlProxy(object):
def __init__(self, player):
self._quit = False
self._player = player
self.server = SimpleXMLRPCServer((self._player.host, self._player.port), logRequests=False, allow_none=True)
self.server.register_instance(self, allow_dotted_names=True)
Thread(target=self.run).start()
def run(self):
while not self._quit:
self.server.handle_request()
def player_move(self, output_spec):
return self._player.player_move(output_spec)
def print_table(self, table_state):
self._player.print_table(table_state)
def join(self):
self._player.add_player()
def rejoin_new(self, ai_id="unchanged"):
self._player.rejoin_new(ai_id)
def rejoin(self, ai_type=0):
self._player.rejoin()
def get_ai_id(self):
return self._player.get_ai_id()
def save_ai_state(self):
self._player.save_ai_state()
def delete_ai(self):
self._player.delete_ai()
def quit(self):
self._player.server.remove_player(self._player.playerID)
self._quit = True
'--url',
dest='url',
help='Interoperability Server URL, example: http://10.10.130.10:80',
required=True)
parser.add_argument(
'--username',
dest='username',
help='Interoperability Username, example: calpoly-broncos',
required=True)
parser.add_argument('--password',
dest='password',
help='Interoperability Password, example: 4597630144',
required=True)
cmd_args = parser.parse_args()
relay = RelayService(url=cmd_args.url,
username=cmd_args.username,
password=cmd_args.password)
server = SimpleXMLRPCServer(
('127.0.0.1', 9000),
logRequests=True,
allow_none=True)
server.register_instance(relay)
try:
print('Use Control-C to exit')
server.serve_forever()
except KeyboardInterrupt:
print('Exiting')
class XMLRPCPlugin(Plugin):
def __init__(self, name, ui):
Plugin.__init__(self, name, ui)
host = options["Plugin", "xmlrpc_host"]
port = options["Plugin", "xmlrpc_port"]
path = options["Plugin", "xmlrpc_path"]
self.server = SimpleXMLRPCServer((host, port))
self.server.RequestHandlerClass.rpc_paths = (path,)
self.server.register_instance(self)
self.thread = threading.Thread(target=self.server.serve_forever)
self.thread.setDaemon(True)
self.thread.start()
def _dispatch(self, method, params):
if method in ("score", "score_mime", "train", "train_mime"):
return getattr(self, method)(*params)
else:
raise xmlrpc.client.Fault(404, '"%s" is not supported' % method)
def train(self, form_dict, extra_tokens, attachments, is_spam=True):
newdict = {}
for (i, k) in list(form_dict.items()):
if isinstance(k, str):
k = k.encode("utf-8")
newdict[i] = k
mime_message = form_to_mime(newdict, extra_tokens, attachments)
mime_message = str(mime_message.as_string(), "utf-8").encode("utf-8")
self.train_mime(mime_message, "utf-8", is_spam)
return ""
def train_mime(self, msg_text, encoding, is_spam):
if self.state.bayes is None:
self.state.create_workers()
if isinstance(msg_text, str):
msg_text = str(msg_text, encoding)
if isinstance(msg_text, str):
msg_text = msg_text.encode("utf-8")
msg = message_from_string(msg_text,
_class=spambayes.message.SBHeaderMessage)
if is_spam:
desired_corpus = "spamCorpus"
else:
desired_corpus = "hamCorpus"
if hasattr(self, desired_corpus):
corpus = getattr(self, desired_corpus)
else:
if hasattr(self, "state"):
corpus = getattr(self.state, desired_corpus)
setattr(self, desired_corpus, corpus)
self.msg_name_func = self.state.getNewMessageName
else:
if is_spam:
fn = storage.get_pathname_option("Storage",
"spam_cache")
else:
fn = storage.get_pathname_option("Storage",
"ham_cache")
storage.ensureDir(fn)
if options["Storage", "cache_use_gzip"]:
factory = FileCorpus.GzipFileMessageFactory()
else:
factory = FileCorpus.FileMessageFactory()
age = options["Storage", "cache_expiry_days"]*24*60*60
corpus = FileCorpus.ExpiryFileCorpus(age, factory, fn,
'[0123456789\-]*',
cacheSize=20)
setattr(self, desired_corpus, corpus)
class UniqueNamer(object):
count = -1
def generate_name(self):
self.count += 1
return "%10.10d-%d" % (int(time.time()), self.count)
Namer = UniqueNamer()
self.msg_name_func = Namer.generate_name
key = self.msg_name_func()
mime_message = str(msg.as_string(), "utf-8").encode("utf-8")
msg = corpus.makeMessage(key, mime_message)
msg.setId(key)
corpus.addMessage(msg)
msg.RememberTrained(is_spam)
def train_spam(self, form_dict, extra_tokens, attachments):
pass
def train_ham(self, form_dict, extra_tokens, attachments):
pass
def score(self, form_dict, extra_tokens, attachments):
"""Score a dictionary + extra tokens."""
newdict = {}
for (i, k) in list(form_dict.items()):
if isinstance(k, str):
k = k.encode("utf-8")
newdict[i] = k
mime_message = form_to_mime(newdict, extra_tokens, attachments)
mime_message = str(mime_message.as_string(), "utf-8").encode("utf-8")
return self.score_mime(mime_message, "utf-8")
def score_mime(self, msg_text, encoding):
"""Score a message representing a MIME document.
The msg argument will be a string in the given encoding.
"""
if self.state.bayes is None:
self.state.create_workers()
if isinstance(msg_text, str):
msg_text = str(msg_text, encoding)
if isinstance(msg_text, str):
msg_text = msg_text.encode("utf-8")
msg = message_from_string(msg_text,
_class=spambayes.message.SBHeaderMessage)
tokens = tokenize(msg)
prob, clues = self.state.bayes.spamprob(tokens, evidence=True)
msg.addSBHeaders(prob, clues)
self.state.record_classification(msg.GetClassification(), prob)
if not self.state.is_test and options["Storage", "cache_messages"]:
msg.setId(self.state.getNewMessageName())
makeMessage = self.state.unknownCorpus.makeMessage
message = makeMessage(msg.getId(), msg.as_string())
self.state.unknownCorpus.addMessage(message)
return prob