class Server(Thread):
def __init__(self,ip,port):
Thread.__init__(self)
self.__port = port
self.__ip = ip
self.webServer = SimpleXMLRPCServer((self.__ip, self.__port))
print "server initialized"
def stopServer(self):
self.webServer.shutdown(self)
def run(self):
#server = SimpleXMLRPCServer(("localhost", self.__port))
server = self.webServer
server.register_introspection_functions()
#server.register_instance(NodeRPCHandler())
server.register_function(add)
server.register_function(delete)
server.register_function(getActiveNodes)
server.serve_forever()
def test(a,b):
print "test succeeded"
print a+b
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__
class KeyValueServer:
_rpc_methods_ = [
'get_robot_state', 'get_laser_data', 'set_robot_pose',
'set_target_pose', 'set_robot_cmd_vel'
]
def __init__(self, address, index, sp):
self.robot = Robot(config.player_port + index, index, sp)
self._serv = SimpleXMLRPCServer(address, allow_none=True)
for name in self._rpc_methods_:
self._serv.register_function(getattr(self, name))
def get_robot_state(self):
return self.robot.get_robot_state()
def get_laser_data(self):
return self.robot.get_laser_data()
def set_robot_pose(self, ppx, ppy, ppa):
return self.robot.set_robot_pose(ppx, ppy, ppa)
def set_target_pose(self, ppx, ppy):
return self.robot.set_target_pose(ppx, ppy)
def set_robot_cmd_vel(self, vx, vy, va):
return self.robot.set_robot_cmd_vel(vx, vy, va)
def serve_forever(self):
self._serv.serve_forever()
def close(self):
self._serv.shutdown()
self._serv.server_close()
def main(*argv):
"""This script is used as i/o api for communication with exabgp
Arguments:
:*argv: unparsed cli arguments
In a separate thread an rpc server is started. This server will be used as an api towards the user.
Stdin and stdout are used for communication with exabgp.
"""
parser = argparse.ArgumentParser(description="ExaBgp rpc server script")
parser.add_argument(
"--host",
default="127.0.0.1",
help="Host where exabgp is running (default is 127.0.0.1)",
)
parser.add_argument("--loglevel", default=logging.DEBUG, help="Log level")
parser.add_argument(
"--logfile",
default="{}/exarpc.log".format(
os.path.dirname(os.path.abspath(__file__))),
help="Log file name.",
)
parser.add_argument("--encoder",
default="json",
help="Exabgp encoder type")
in_args = parser.parse_args(*argv)
logging.basicConfig(filename=in_args.logfile, level=in_args.loglevel)
storage = ExaStorage()
rpcserver = SimpleXMLRPCServer((in_args.host, 8000), allow_none=True)
rpcserver.register_instance(Rpcs(storage))
trpc = threading.Thread(target=rpcserver.serve_forever)
trpc.start()
epoll = select.epoll()
epoll.register(sys.__stdin__,
select.EPOLLIN | select.EPOLLERR | select.EPOLLHUP)
try:
while True:
logging.debug("Epoll loop")
events = epoll.poll(10)
for fd, event_type in events:
logging.debug("Epoll returned: {},{}".format(fd, event_type))
if event_type != select.EPOLLIN:
raise Exception("Unexpected epoll event")
else:
data = sys.stdin.readline()
logging.debug(
"Data recevied from exabgp: {}.".format(data))
exa_msg_handler(storage, data, in_args.encoder)
except Exception as e:
logging.warn("Exception occured: {}".format(e))
finally:
rpcserver.shutdown()
trpc.join()
class ProntRPC(object):
server = None
def __init__(self, pronsole, port=RPC_PORT):
self.pronsole = pronsole
used_port = port
while True:
try:
self.server = SimpleXMLRPCServer(("localhost", used_port),
allow_none=True,
logRequests=False)
if used_port != port:
logging.warning(
_("RPC server bound on non-default port %d") %
used_port)
break
except socket.error as e:
if e.errno == 98:
used_port += 1
continue
else:
raise
self.server.register_function(self.get_status, 'status')
self.thread = Thread(target=self.run_server)
self.thread.start()
def run_server(self):
self.server.serve_forever()
def shutdown(self):
self.server.shutdown()
self.thread.join()
def get_status(self):
if self.pronsole.p.printing:
progress = 100 * float(self.pronsole.p.queueindex) / len(
self.pronsole.p.mainqueue)
elif self.pronsole.sdprinting:
progress = self.percentdone
else:
progress = None
if self.pronsole.p.printing or self.pronsole.sdprinting:
eta = self.pronsole.get_eta()
else:
eta = None
if self.pronsole.tempreadings:
temps = parse_temperature_report(self.pronsole.tempreadings)
else:
temps = None
z = self.pronsole.curlayer
return {
"filename": self.pronsole.filename,
"progress": progress,
"eta": eta,
"temps": temps,
"z": z,
}
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)
class FuncionS():
def abre(self,puerto=8000,IP='127.0.0.1'):
self.server = SimpleXMLRPCServer((IP, puerto))
self.server.register_instance(MyFuncs())
self.server.serve_forever()
def cerrar(self):
self.server.shutdown()
self.server.server_close()
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)
class OmsSimulatorServer(object):
"""
Dispatches an OmsSimulator with a SimpleXMLRPCServer. Normally,
this is intended to be run outside of pyon.
"""
def __init__(self, host, port, thread=False):
"""
@param host Hostname for the service
@param port Port for the service
@param thread If True, a thread is launched to call serve_forever on
the server. Do not use this within a pyon-dominated
environment because of gevent monkey patching
behavior that doesn't play well with threading.Thread
(you'll likely see the thread blocked). By default False.
"""
self._sim = OmsSimulator()
self._server = SimpleXMLRPCServer((host, port), allow_none=True)
self._server.register_introspection_functions()
self._server.register_instance(self._sim, allow_dotted_names=True)
log.info("OMS simulator xmlrpc server listening on %s:%s ..." % (host, port))
if thread:
self._check_pyon()
runnable = Thread(target=self._server.serve_forever)
runnable.start()
log.info("started thread.")
else:
self._server.serve_forever()
@property
def methods(self):
return self._server.system_listMethods()
@property
def oms_simulator(self):
return self._sim
def shutdown(self):
log.info("_server.shutdown called.")
if self._sim:
self._sim = None
self._server.shutdown()
self._server = None
@staticmethod
def _check_pyon():
"""
Prints a warning message if pyon is detected.
"""
import sys
if "pyon" in sys.modules:
m = "!! WARNING: pyon in sys.modules !!"
s = "!" * len(m)
sys.stderr.write("\n%s\n%s\n%s\n\n" % (s, m, s))
def execute_main(listen_port=None, spec_file=None, aut_file=None, show_gui=False):
logging.info("Hello. Let's do this!")
# Create the XML-RPC server
if listen_port is None:
# Search for a port we can successfully bind to
while True:
listen_port = random.randint(10000, 65535)
try:
xmlrpc_server = SimpleXMLRPCServer(("127.0.0.1", listen_port), logRequests=False, allow_none=True)
except socket.error as e:
pass
else:
break
else:
xmlrpc_server = SimpleXMLRPCServer(("127.0.0.1", listen_port), logRequests=False, allow_none=True)
# Create the execution context object
e = LTLMoPExecutor()
# Register functions with the XML-RPC server
xmlrpc_server.register_instance(e)
# Kick off the XML-RPC server thread
XMLRPCServerThread = threading.Thread(target=xmlrpc_server.serve_forever)
XMLRPCServerThread.daemon = True
XMLRPCServerThread.start()
logging.info("Executor listening for XML-RPC calls on http://127.0.0.1:{} ...".format(listen_port))
# Start the GUI if necessary
if show_gui:
# Create a subprocess
logging.info("Starting GUI window...")
p_gui = subprocess.Popen(
["python", "-u", os.path.join(project.get_ltlmop_root(), "lib", "simGUI.py"), str(listen_port)]
)
# Wait for GUI to fully load, to make sure that
# to make sure all messages are redirected
e.externalEventTargetRegistered.wait()
if spec_file is not None:
# Tell executor to load spec & aut
# if aut_file is None:
# aut_file = spec_file.rpartition('.')[0] + ".aut"
e.initialize(spec_file, aut_file, firstRun=True)
# Start the executor's main loop in this thread
e.run()
# Clean up on exit
logging.info("Waiting for XML-RPC server to shut down...")
xmlrpc_server.shutdown()
XMLRPCServerThread.join()
class CIOMSSimulatorServer(object):
"""
Dispatches an CIOMSSimulator with a SimpleXMLRPCServer. Normally,
this is intended to be run outside of pyon.
"""
def __init__(self, host, port, thread=False):
"""
@param host Hostname for the service
@param port Port for the service
@param thread If True, a thread is launched to call serve_forever on
the server. Do not use this within a pyon-dominated
environment because of gevent monkey patching
behavior that doesn't play well with threading.Thread
(you'll likely see the thread blocked). By default False.
"""
self._sim = CIOMSSimulator()
self._server = SimpleXMLRPCServer((host, port), allow_none=True)
self._server.register_introspection_functions()
self._server.register_instance(self._sim, allow_dotted_names=True)
log.info("OMS simulator xmlrpc server listening on %s:%s ..." %
(host, port))
if thread:
self._check_pyon()
runnable = Thread(target=self._server.serve_forever)
runnable.start()
log.info("started thread.")
else:
self._server.serve_forever()
@property
def methods(self):
return self._server.system_listMethods()
@property
def oms_simulator(self):
return self._sim
def shutdown(self):
log.info("_server.shutdown called.")
if self._sim:
self._sim = None
self._server.shutdown()
self._server = None
@staticmethod
def _check_pyon():
"""
Prints a warning message if pyon is detected.
"""
import sys
if 'pyon' in sys.modules:
m = "!! WARNING: pyon in sys.modules !!"
s = "!" * len(m)
sys.stderr.write("\n%s\n%s\n%s\n\n" % (s, m, s))
class CanapeXMLRPCServer(threading.Thread):
def __init__(self, hostname='localhost', port=8080):
threading.Thread.__init__(self)
self.daemon = True
self.server = SimpleXMLRPCServer((hostname, port), allow_none=True)
def run(self):
self.server.register_instance(CanapeInterface())
self.server.serve_forever()
def shutdown(self):
self.server.shutdown()
class ProntRPC(object):
server = None
def __init__(self, pronsole, port = RPC_PORT):
self.pronsole = pronsole
used_port = port
while True:
try:
self.server = SimpleXMLRPCServer(("localhost", used_port),
allow_none = True,
logRequests = False)
if used_port != port:
logging.warning(_("RPC server bound on non-default port %d") % used_port)
break
except socket.error as e:
if e.errno == 98:
used_port += 1
continue
else:
raise
self.server.register_function(self.get_status, 'status')
self.thread = Thread(target = self.run_server)
self.thread.start()
def run_server(self):
self.server.serve_forever()
def shutdown(self):
self.server.shutdown()
self.thread.join()
def get_status(self):
if self.pronsole.p.printing:
progress = 100 * float(self.pronsole.p.queueindex) / len(self.pronsole.p.mainqueue)
elif self.pronsole.sdprinting:
progress = self.percentdone
else: progress = None
if self.pronsole.p.printing or self.pronsole.sdprinting:
eta = self.pronsole.get_eta()
else:
eta = None
if self.pronsole.tempreadings:
temps = parse_temperature_report(self.pronsole.tempreadings)
else:
temps = None
z = self.pronsole.curlayer
return {"filename": self.pronsole.filename,
"progress": progress,
"eta": eta,
"temps": temps,
"z": z,
}
class XMLRPCHarness(object):
"""
A setUp/tearDown harness that will provide an XMLRPC Server for us
to test against.
"""
HOST = "localhost"
PORT = 8999
def __init__(self, *args, **kwds):
super(XMLRPCHarness, self).__init__(*args, **kwds)
self.server = None
self.thread = None
self.dummy = None
def setUp(self):
assert(self.server is None)
assert(self.thread is None)
self.dummy = Dummy()
self.server = SimpleXMLRPCServer((self.HOST, self.PORT),
logRequests=False)
self.server.register_function(self.dummy.get, "get")
self.server.register_function(self.dummy.steal, "steal")
self.server.register_multicall_functions()
self.thread = Thread(target=self.server.serve_forever,
kwargs={"poll_interval":0.2})
self.thread.start()
def tearDown(self):
assert(self.server is not None)
assert(self.thread is not None)
self.server.shutdown()
self.server.socket.close()
self.server = None
self.dummy = None
self.thread.join()
self.thread = None
def get_client(self):
assert(self.server is not None)
assert(self.thread is not None)
return ServerProxy("http://%s:%i" % (self.HOST, self.PORT))
class ExecutorServer(object):
"""ExecutorServer"""
def __init__(self, conf):
self._conf = conf
self._listen_host = conf.get("listen_host", "0.0.0.0")
self._listen_port = int(conf.get("listen_port", 51290))
self._listen_addr = (self._listen_host, self._listen_port)
self._executor = Executor(conf)
self._rpc_server = SimpleXMLRPCServer(self._listen_addr,
logRequests=False,
allow_none=True)
self._rpc_server.register_introspection_functions()
self._rpc_server.register_function(self._executor.execute, "execute")
self._quit = False
pass
def _rpc_tf(self):
logger.info("rpc thread started")
logger.info("rpc server starting [host:%s] [port:%d]" %
(self._listen_host, self._listen_port))
try:
self._rpc_server.serve_forever()
except Exception as e:
logger.error("Exception: %s\n%s" %
(str(e), traceback.format_exc()))
logger.info("rpc thread exited")
pass
def start(self):
logger.info("executor started")
rpc_thread = threading.Thread(target=self._rpc_tf)
rpc_thread.setDaemon(True)
rpc_thread.start()
# Glances in the past 500 years, an encounter this life. ~.~ . Not supported. #
while not self._quit:
time.sleep(500 * 365 * 24 * 60 * 60 / 500)
logger.info("executor exited")
pass
def stop(self):
logger.info("stop executor")
self._executor.stop()
self._quit = True
self._rpc_server.shutdown()
pass
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 Server(object):
""" A general purpose XML-RPC-exposing server.
"""
def __init__(self, listen_ip='0.0.0.0'):
""" Prepare the XML-RPC server, map the exposed functions.
"""
self.server = SimpleXMLRPCServer((listen_ip, PORT), logRequests=False)
self.server.register_function(self._init, 'init')
self.server.register_function(self._call, 'call')
self.server.register_function(self._get, 'get')
self.server.register_function(self._set, 'set')
self.cls = {}
def start(self):
""" Start the server.
"""
self.server.serve_forever()
def stop(self):
""" Stop the server.
"""
self.server.shutdown()
def _init(self, cls_src, *args):
""" Register and initialise a class, class id. Only to be called via
XML-RPC.
"""
existing_classes = dir()
exec(cls_src)
new_class = [c for c in dir() if c not in existing_classes][0]
next_id = len(self.cls)
self.cls[next_id] = eval(new_class)(*args)
return next_id
def _call(self, cls_id, method, *args):
""" Call a method. Only to be called via XML-RPC.
"""
return getattr(self.cls[cls_id], method)(*args)
def _get(self, cls_id, attr):
""" Return the value of an attribute. Only to be called via XML-RPC.
"""
return getattr(self.cls[cls_id], attr)
def _set(self, cls_id, attr, val):
""" Set the value of an attribute. Only to be called via XML-RPC.
"""
setattr(self.cls[cls_id], attr, val)
return 0
class Server:
"""It's a server"""
#----------------------------------------------------------------------
def __init__(self, port=7777):
# Create server
hostname = socket.gethostname()
self.server = SimpleXMLRPCServer((hostname, port),
requestHandler=RequestHandler,
allow_none=True)
self.server.register_introspection_functions()
self.server.register_function(self.StopServer, 'shutdown')
# Register pow() function; this will use the value of
# pow.__name__ as the name, which is just 'pow'.
#server.register_function(pow)
# Register a function under a different name
#def adder_function(x,y):
#return x + y
# Register an instance; all the methods of the instance are
# published as XML-RPC methods (in this case, just 'div').
# class MyFuncs:
# def div(self, x, y):
# return x // y
#server.register_instance(MyFuncs())
def Start(self):
# Run the server's main loop
print 'start'
self.server.serve_forever()
def StopServer(self):
# Run the server's main loop
print 'stop'
self.server.shutdown()
def GetServer(self):
return self.server
def RegisterFunction(self, function, function_name):
self.server.register_function(function, function_name)
def RegisterInstance(self, instance):
self.server.register_instance(instance)
class CVManager(object, SimpleXMLRPCRequestHandler):
def __init__(self, engines):
self.logger = getLogger("CVWorker")
rpc_paths = ("/RPC2",)
# Create server
self.server = SimpleXMLRPCServer(("localhost", 8000))
self.server.register_introspection_functions()
self.engines = engines
self.cur_id = 0
self.cv_workers = []
# message queue to communicate with controller thread
self.msgqueue = None
# register cv vm workers into its corresponding
# engines
# somehow the logger will output msgs twice for each debug call
def register_vm(ip_addr, category):
for engine in self.engines:
if category == engine.type:
worker = CVWorker(ip_addr, category, self.cur_id)
engine.register(worker)
self.cv_workers.append(worker)
self.cur_id += 1
self.logger.debug("current worker list: ")
for worker in self.cv_workers:
self.logger.debug(worker)
self.logger.debug("worker list len: " + str(len(self.cv_workers)))
return True
self.logger.debug("{} failed to register. Invalid category".format(ip_addr))
return False
self.server.register_function(register_vm, "register_vm")
def hello(name):
return "{}, server is live and well!\n".format(name)
self.server.register_function(hello, "hello")
self.logger.info("server started!")
def shutdown(self):
self.server.shutdown()
def run(self, msgqueue):
self.msgqueue = msgqueue
self.server.serve_forever()
def getAllWorkers(self):
return self.cv_workers
def main():
## Cmd line parameters
parser = argparse.ArgumentParser(
description='MyOffice Document API. Сервер генерации документов.')
parser.add_argument('-p', action="store", dest="port", \
default='8000', type=int, \
help='Порт. Значение по умолчанию 8000')
parser.add_argument('-s', action="store", dest="host", default='127.0.0.1', \
help='Хост. Значение по умолчанию 127.0.0.1')
parser.add_argument('-t', action="store", dest="folder_templ", default='./template', \
help='Путь к каталогу шаблонов. Значение по умолчанию ./template')
parser.add_argument('-o', action="store", dest="folder_out", default='./out', \
help='Путь к каталогу целевых документов. Значение по умоланию ./out')
#parser.add_argument('-d', '--debug', action='store_true', help='Enable debug mode with debug output')
parser.add_argument('-f', action="append", dest="formats", default=["XODT", "PDF"], \
help='Форматы документов-шаблонов. Используйте несколько ключей чтобы перечислить все необходимые форматы',)
args = parser.parse_args()
logger = logging.getLogger('mofserver')
server = SimpleXMLRPCServer((args.host, args.port),
allow_none=True,
logRequests=True)
server.register_introspection_functions(
) # для удаленных вызовов listMethods, methodHelp
#
config = {}
config["folder_templ"] = args.folder_templ
config["folder_out"] = args.folder_out
config["formats"] = []
#config["log"] = logging
for p in args.formats:
config["formats"].append(p.upper())
if len(config["formats"]) < 1:
logger.warning('Форматы для обработки не указаны.')
server.register_instance(RPCDispatcher(config))
#
try:
logger.info('Для завершения работы сервера нажмите Ctrl-C')
server.serve_forever()
except KeyboardInterrupt:
logger.info("Сервер завершает работу...")
logging.shutdown()
server.shutdown()
class RpcThread(threading.Thread):
def __init__(self, simulator):
super(RpcThread, self).__init__()
self.simulator = simulator
def run(self):
self.server = SimpleXMLRPCServer(('localhost', SIMULATOR_PORT),
allow_none=True)
self.server.register_instance(self.simulator)
log.info("Listening on %s" % SIMULATOR_PORT)
self.server.serve_forever()
def stop(self):
self.server.shutdown()
class Server:
"""It's a server"""
#----------------------------------------------------------------------
def __init__(self, port=7777):
# Create server
hostname = socket.gethostname()
self.server = SimpleXMLRPCServer((hostname, port),
requestHandler=RequestHandler, allow_none=True)
self.server.register_introspection_functions()
self.server.register_function(self.StopServer, 'shutdown')
# Register pow() function; this will use the value of
# pow.__name__ as the name, which is just 'pow'.
#server.register_function(pow)
# Register a function under a different name
#def adder_function(x,y):
#return x + y
# Register an instance; all the methods of the instance are
# published as XML-RPC methods (in this case, just 'div').
# class MyFuncs:
# def div(self, x, y):
# return x // y
#server.register_instance(MyFuncs())
def Start(self):
# Run the server's main loop
print 'start'
self.server.serve_forever()
def StopServer(self):
# Run the server's main loop
print 'stop'
self.server.shutdown()
def GetServer(self):
return self.server
def RegisterFunction(self, function, function_name):
self.server.register_function(function, function_name)
def RegisterInstance(self, instance):
self.server.register_instance(instance)
def main():
"""
Example server for serving INFO of all locally running redis-servers via XML-RPC.
Since it is based on the non-production-quality LocalShardWatcher, it might fail for
Redis servers using non-standard configurations, and will not work for Redises that
require authentication.
"""
parser = argparse.ArgumentParser(
description=main.__doc__,
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-p',
'--port',
type=int,
default=50051,
help='the port on which the server should listen')
parser.add_argument('-a',
'--address',
default='127.0.0.1',
help='the address on which the server should listen')
args = parser.parse_args()
# prevent KeyboardInterrupt thrown in a greenlet from causing a stack trace to be printed
gevent.hub.Hub.NOT_ERROR = (KeyboardInterrupt, )
# Python's xmlrpc module serializes integers as i4 (32-bits) out of the box. This line causes all ints to
# be serialized as i8 (64-bits), as some Redis INFO values require the additional space.
xmlrpclib.Marshaller.dispatch[int] = lambda _, value, write: write(
'<value><i8>{}</i8></value>'.format(value))
print('Starting INFO server on {}:{}...'.format(args.address, args.port))
server = SimpleXMLRPCServer((args.address, args.port))
server.register_instance(redis_info_provider.InfoProviderServicer())
Thread(target=server.serve_forever).start()
try:
with redis_info_provider.LocalShardWatcher(
), redis_info_provider.InfoPoller():
print('INFO server running.')
gevent.sleep(float('inf'))
except KeyboardInterrupt:
print('INFO server stopping.')
finally:
server.shutdown()
server.server_close()
def main(*argv):
"""This script is used as i/o api for communication with exabgp
Arguments:
:*argv: unparsed cli arguments
In a separate thread an rpc server is started. This server will be used as an api towards the user.
Stdin and stdout are used for communication with exabgp.
"""
parser = argparse.ArgumentParser(description='ExaBgp rpc server script')
parser.add_argument('--host', default='127.0.0.1', help='Host where exabgp is running (default is 127.0.0.1)')
parser.add_argument('--loglevel', default=logging.DEBUG, help='Log level')
parser.add_argument('--logfile', default='{}/exarpc.log'.format(os.path.dirname(os.path.abspath(__file__))),
help='Log file name.')
parser.add_argument('--encoder', default='json', help='Exabgp encoder type')
in_args = parser.parse_args(*argv)
logging.basicConfig(filename=in_args.logfile, level=in_args.loglevel)
storage = ExaStorage()
rpcserver = SimpleXMLRPCServer((in_args.host, 8000), allow_none=True)
rpcserver.register_instance(Rpcs(storage))
trpc = threading.Thread(target=rpcserver.serve_forever)
trpc.start()
epoll = select.epoll()
epoll.register(sys.__stdin__, select.EPOLLIN | select.EPOLLERR | select.EPOLLHUP)
try:
while True:
logging.debug('Epoll loop')
events = epoll.poll(10)
for fd, event_type in events:
logging.debug('Epoll returned: {},{}'.format(fd, event_type))
if event_type != select.EPOLLIN:
raise Exception('Unexpected epoll event')
else:
data = sys.stdin.readline()
logging.debug('Data recevied from exabgp: {}.'.format(data))
exa_msg_handler(storage, data, in_args.encoder)
except Exception as e:
logging.warn('Exception occured: {}'.format(e))
finally:
rpcserver.shutdown()
trpc.join()
class servernode(threading.Thread):
def __init__(self,ip,port):
super(servernode,self).__init__()
self.ip = ip
self.port = port
self.server = SimpleXMLRPCServer((ip, port))
self.server.register_introspection_functions()
def register_function(self, function):
self.server.register_function(function)
def run(self):
self.server.serve_forever()
def stop_server(self):
self.server.shutdown()
self.server.server_close()
class RaidServer():
def __init__(self, server_port):
self.memory = Memory.Operations()
self.server = SimpleXMLRPCServer(("localhost", server_port), allow_none=True, logRequests=False)
print "Listening on localhost : port ", server_port
#Register all functions required for RPC
self.server.register_instance(self.memory)
self.server.register_introspection_functions()
return
def start_server(self):
#Start the server
self.server.serve_forever()
def shutdown_server(self):
#Shutdown the server
self.server.shutdown()
class RTevald():
def __init__(self, options, log):
self.options = options
self.log = log
self.server = None
self.config = RTevald_config()
def __prepare_datadir(self):
startdir = os.getcwd()
for dir in self.config.datadir.split("/"):
if dir is '':
continue
if not os.path.exists(dir):
os.mkdir(dir, 0700)
os.chdir(dir)
if not os.path.exists('queue'):
os.mkdir('queue', 0700)
os.chdir(startdir)
def StartServer(self):
# Create server
self.server = SimpleXMLRPCServer(
(self.options.listen, self.options.port),
requestHandler=RequestHandler)
self.server.register_introspection_functions()
# setup a class to handle requests
self.server.register_instance(
xmlrpc_API1.XMLRPC_API1(self.config, nodbaction=True, debug=True))
# Run the server's main loop
self.log.Log(
"StartServer",
"Listening on %s:%i" % (self.options.listen, self.options.port))
try:
self.__prepare_datadir()
self.server.serve_forever()
except KeyboardInterrupt:
self.log.Log("StartServer", "Server caught SIGINT")
self.server.shutdown()
finally:
self.log.Log("StartServer", "Server stopped")
def StopServer(self):
self.server.shutdown()
class XMLRPCContainer( DaemonContainer ):
def __init__(self, environment):
super(XMLRPCContainer, self).__init__(environment)
self.address = (environment.get("host","localhost"), environment.get("port", 9001))
self.server = SimpleXMLRPCServer(self.address)
self.server.register_introspection_functions()
self.server.register_multicall_functions()
self.server_thread = threading.Thread(self.server.serve_forever)
def on_start(self):
self.server_thread.stop()
def on_stop(self):
self.server.shutdown()
def register_service(self, name, method):
pass
class RPCSink(Sink):
"""
RPC sink. This sink forwards events as Event instances and doesn't need a
translator.
Configuration options:
- address: determines, on which address the socket listens
- port: port of the RPC server
"""
def __init__(self, num, config, logger, queue):
Sink.__init__(self, num, config, logger, queue)
if not self.options.has_key("address"):
self.raiseException("No 'address' specified in options.")
if not self.options.has_key("port"):
self.raiseException("No 'port' specified in options.")
if not self.options['port'].isdigit():
self.raiseException("Option 'port': must be a number.")
self.address = self.options['address']
self.port = int(self.options['port'])
self.server = SimpleXMLRPCServer((self.address, self.port), logRequests=False, allow_none=True)
self.server.register_function(self.getEvents)
def finish(self):
"""
Stop the sink and shut the server down.
"""
Sink.finish(self)
self.server.shutdown()
def run(self):
"""
The main thread function.
"""
self.server.serve_forever()
def getEvents(self):
events = []
while self.queue.qsize()>0:
event = self.queue.get()
events.append(dict([(k, event.__dict__[k])
for k in constants.EVENT_FIELDS
if event.__dict__.has_key(k)]))
self.queue.task_done()
return events
class XmlRpcServer(object):
"""
XMLRPC service, exported functions are in class _RpcFuncs
"""
def __init__(self, root, host, port):
self._root = root
self.host = host
self.port = port
self._server = SimpleXMLRPCServer((self.host, self.port))
self._server.register_introspection_functions()
self._server.register_instance(_RpcFuncs(self._root))
def start(self):
logger.info('Listening for XMLRPC clients on %s:%d', self.host,
self.port)
self._server.serve_forever()
def shutdown(self):
self._server.shutdown()
class RTevald():
def __init__(self, options, log):
self.options = options
self.log = log
self.server = None
self.config = RTevald_config()
def __prepare_datadir(self):
startdir = os.getcwd()
for dir in self.config.datadir.split("/"):
if dir is '':
continue
if not os.path.exists(dir):
os.mkdir(dir, 0700)
os.chdir(dir)
if not os.path.exists('queue'):
os.mkdir('queue', 0700)
os.chdir(startdir)
def StartServer(self):
# Create server
self.server = SimpleXMLRPCServer((self.options.listen, self.options.port),
requestHandler=RequestHandler)
self.server.register_introspection_functions()
# setup a class to handle requests
self.server.register_instance(xmlrpc_API1.XMLRPC_API1(self.config, nodbaction=True, debug=True))
# Run the server's main loop
self.log.Log("StartServer", "Listening on %s:%i" % (self.options.listen, self.options.port))
try:
self.__prepare_datadir()
self.server.serve_forever()
except KeyboardInterrupt:
self.log.Log("StartServer", "Server caught SIGINT")
self.server.shutdown()
finally:
self.log.Log("StartServer", "Server stopped")
def StopServer(self):
self.server.shutdown()
class XMLRPCServerThread(object):
def __init__(self, port):
self.server = SimpleXMLRPCServer(("localhost", port),
requestHandler=Handler,
logRequests=False,
allow_none=True)
def add_instance(self, instance):
for key in dir(instance):
attr = getattr(instance, key)
if isinstance(attr, self.__init__.__class__):
self.server.register_function(
attr, instance.__class__.__name__ + "_" +
getattr(attr, "_real_name", attr.__name__))
def __call__(self):
self.server.serve_forever()
def stop(self):
self.server.shutdown()
self.server.server_close()
class LogServer(Thread):
def __init__(self, ip, port, uri, output):
super(LogServer, self).__init__()
self.running = True
rpc_paths = ('/RPC2', )
# print ("impleXMLRPCServer({})..").format(iptuple)
self.server = SimpleXMLRPCServer((ip, port),
requestHandler=RequestHandler)
self.server.register_introspection_functions()
self.outputfile = output
self.server.register_instance(MyFuncs(self.outputfile))
def register_function(self, function):
log.info("%s\r\nLogServer started".format("=" * 30, ))
self.server.register_function(function)
def run(self):
self.server.serve_forever()
def stop_server(self):
self.server.shutdown()
self.server.server_close()
class ScriptServer(object):
def __init__(self, port=default_port, methods={}):
self.server = SimpleXMLRPCServer(
('localhost', port),
requestHandler=RequestHandler,
logRequests=False,
allow_none=True)
for name,func in methods.items():
self.server.register_function(func, name)
if 'python' not in methods:
self.server.register_function(_python, 'python')
self.server.register_function(lambda: os.getpid(), 'pid')
server = self.server
self.t = Thread(target=lambda: server.serve_forever())
self.t.start()
def __del__(self):
print("Shutting down ScriptServer")
self.server.shutdown()
class RPCServer(threading.Thread):
"""
The RPCServer thread provides an API for external programs to interact
with MOM.
"""
def __init__(self, config, host_monitor, guest_manager, policy_engine):
threading.Thread.__init__(self, name="RPCServer")
self.setDaemon(True)
self.config = config
self.threads = { 'host_monitor': host_monitor,
'guest_manager': guest_manager,
'policy_engine': policy_engine }
self.logger = logging.getLogger('mom.RPCServer')
self.start()
def create_server(self):
try:
port = self.config.getint('main', 'rpc-port')
except ValueError:
return None
if port is None or port < 0:
return None
self.server = SimpleXMLRPCServer(("localhost", port),
requestHandler=RequestHandler, logRequests=0)
self.server.register_introspection_functions()
self.server.register_instance(MOMFuncs(self.config, self.threads))
def shutdown(self):
if self.server is not None:
self.server.shutdown()
def run(self):
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")
class IpyServerXMLRPC(threading.Thread):
def __init__(self, port=9876, logging = False):
""" Simple creation of the XMLRPC server in a separate thread"""
super(IpyServerXMLRPC, self).__init__()
self.setDaemon(True)
self.server = SimpleXMLRPCServer(("localhost",port),logRequests=logging)
self.server.register_function(self.send)
self.server.register_function(self.test_pylab)
if logging:
print "setup complete at: %s port %d" % self.get_socket_name()
def run(self):
""" The main worker of the threa. No separate loop as it is already present in serve_forever()"""
self.server.serve_forever()
def send(self,data):
""" Gets the data from vim and splits it in parts (just in case). Passes to ipython.
Returns the number of lines being pasted to ipython"""
data = data.split('\n')
cmds = list()
for line in data:
cmds.append(line)
ip=IPython.ipapi.get()
ip.runlines(cmds)
return len(cmds)
def test_pylab(self):
ip=IPython.ipapi.get()
ip.runlines('a = logspace(1,10,101)')
ip.runlines('print a')
def kill(self):
""" Kills the server. Should be run from a separate thread, such as the ipython thread.
"""
print 'shutting down vim server'
self.server.shutdown()
raise IPython.ipapi.TryNext
def get_socket_name(self):
return self.server.socket.getsockname()
class Source(threading.Thread):
''' Facade for simple remote communication using XMLRPCServer.
'''
def __init__(self, addr):
threading.Thread.__init__(self)
ip, port = addr
self.addr = addr
self.server = SimpleXMLRPCServer((ip, port),
requestHandler=RequestHandler,
logRequests=False,
allow_none=True)
# self.server.register_introspection_functions()
def register_function(self, func):
self.server.register_function(func, 'send')
def run(self):
self.server.serve_forever()
def stop(self):
self.server.shutdown()
self.server.server_close()
class LibvirtXMLRpcServer(object):
def __init__(self, uri=None, host=HOSTNAME, port=PORT, all=False):
"""
:param uri: Libvirt connection URI. see virsh(1) also.
:param host: Host in which this server instance runs
:param port: Listening port
:param all: If True, all methods of libvirt connection object will be
registered and exported to clients.
"""
self._server = SimpleXMLRPCServer((host, port))
self._conn = libvirt.open(uri)
if all:
self.register_instance(self._conn)
else:
self.register_functions(self._conn)
self._server.register_introspection_functions()
def run(self):
try:
logging.info("Starting. (Exit with '^C')")
self._server.serve_forever()
except KeyboardInterrupt:
logging.info("Exiting ...")
self._server.shutdown()
def register_instance(self, conn):
self._server.register_instance(conn)
def register_functions(self, conn):
for fn in dir(conn):
f = getattr(conn, fn)
if f:
self._server.register_function(f, fn)
class CIOMSSimulatorServer(object):
"""
Dispatches an CIOMSSimulator with a SimpleXMLRPCServer.
Intended to be run outside of pyon.
"""
def __init__(self, host, port, inactivity_period=None):
"""
Creates a SimpleXMLRPCServer and starts a Thread where serve_forever
is called on the server.
@param host Hostname for the service
@param port Port for the service
"""
self._running = True
self._sim = CIOMSSimulatorWithExit(self)
if log.isEnabledFor(logging.DEBUG):
ser = NetworkUtil.serialize_network_definition(self._sim._ndef)
log.debug("network serialization:\n %s" % ser.replace('\n', '\n '))
log.debug("network.get_map() = %s\n" % self._sim.config.get_platform_map())
self._server = SimpleXMLRPCServer((host, port), allow_none=True)
actual_port = self._server.socket.getsockname()[1]
uri = "http://%s:%s/" % (host, actual_port)
# write the URI to a file for launching process to see it:
with open("logs/rsn_oms_simulator.yml", 'w') as f:
f.write("rsn_oms_simulator_uri=%s\n" % uri)
self._server.register_introspection_functions()
self._server.register_instance(self._sim, allow_dotted_names=True)
log.info("Methods:\n\t%s", "\n\t".join(self._server.system_listMethods()))
self._check_pyon()
runnable = Thread(target=self._server.serve_forever)
runnable.setDaemon(True)
runnable.start()
log.info("OMS simulator xmlrpc server listening on %s" % uri)
if inactivity_period:
self._sim.x_exit_inactivity(inactivity_period)
def shutdown_server(self):
self._running = False
if self._sim:
log.info("RSN OMS simulator exiting...")
self._sim = None
self._server.shutdown()
self._server = None
def wait_until_shutdown(self):
while self._running:
time.sleep(1)
self.shutdown_server()
@staticmethod
def _check_pyon():
"""
Prints a warning message if pyon is detected.
"""
if 'pyon' in sys.modules:
m = "!! WARNING: pyon in sys.modules !!"
s = "!" * len(m)
sys.stderr.write("\n%s\n%s\n%s\n\n" % (s, m, s))
def execute_main(listen_port=None,
spec_file=None,
aut_file=None,
show_gui=False):
logging.info("Hello. Let's do this!")
# Create the XML-RPC server
if listen_port is None:
# Search for a port we can successfully bind to
while True:
listen_port = random.randint(10000, 65535)
try:
xmlrpc_server = SimpleXMLRPCServer(("127.0.0.1", listen_port),
logRequests=False,
allow_none=True)
except socket.error as e:
pass
else:
break
else:
xmlrpc_server = SimpleXMLRPCServer(("127.0.0.1", listen_port),
logRequests=False,
allow_none=True)
# Create the execution context object
e = LTLMoPExecutor()
# Register functions with the XML-RPC server
xmlrpc_server.register_instance(e)
# Kick off the XML-RPC server thread
XMLRPCServerThread = threading.Thread(target=xmlrpc_server.serve_forever)
XMLRPCServerThread.daemon = True
XMLRPCServerThread.start()
logging.info(
"Executor listening for XML-RPC calls on http://127.0.0.1:{} ...".
format(listen_port))
# Start the GUI if necessary
if show_gui:
# Create a subprocess
logging.info("Starting GUI window...")
p_gui = subprocess.Popen(
[sys.executable, "-u", "-m", "lib.simGUI",
str(listen_port)])
# Wait for GUI to fully load, to make sure that
# to make sure all messages are redirected
e.externalEventTargetRegistered.wait()
if spec_file is not None:
# Tell executor to load spec & aut
#if aut_file is None:
# aut_file = spec_file.rpartition('.')[0] + ".aut"
e.initialize(spec_file, aut_file, firstRun=True)
# Start the executor's main loop in this thread
e.run()
# Clean up on exit
logging.info("Waiting for XML-RPC server to shut down...")
xmlrpc_server.shutdown()
XMLRPCServerThread.join()
logging.info("XML-RPC server shutdown complete. Goodbye.")
if success:
CURRENT_STATUS = STATUS_COMPLETED
else:
if error:
ERROR_MESSAGE = str(error)
CURRENT_STATUS = STATUS_FAILED
RESULTS_FOLDER = results
return True
if __name__ == "__main__":
try:
if not BIND_IP:
BIND_IP = socket.gethostbyname(socket.gethostname())
print("[+] Starting agent on %s:%s ..." % (BIND_IP, BIND_PORT))
# Disable DNS lookup, by Scott D.
def FakeGetFQDN(name=""):
return name
socket.getfqdn = FakeGetFQDN
server = SimpleXMLRPCServer((BIND_IP, BIND_PORT), allow_none=True)
server.register_instance(Agent())
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
class ServerThread(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.name = name
self.server = SimpleXMLRPCServer(("localhost", common.port), requestHandler=RequestHandler)
class Functions:
def getPeers(self, peers):
for u in peers:
if u not in common.known_urls:
common.known_urls.append(u)
return common.known_urls
def getHashes(self):
return common.hashes
def ping(self, vector):
common.updateVector(vector, 0)
if common.write == True or common.read == True:
common.updateMessageList(vector, common.message_type.PING)
return 1
def getPort(self):
return common.port
def sendPasswords(self, pow1, pow2, vector):
if pow2[0] in known_pows2:
return 0
if md5(pow1[0]).hexdigest() != pow2[0]:
return 0
common.updateVector(vector, 0)
common.m_pows.acquire()
try:
common.known_pows1.append(pow1[0])
common.known_pows2.append(pow2[0])
finally:
common.m_pows.release()
return 1
def broadcastPOW(self, pow1, pow2, vector):
common.updateVector(vector, 1)
common.m_pows.acquire()
try:
for p in pow2:
if p not in known_pows2:
common.known_pows1.append(p)
common.known_pows2.append(p)
finally:
common.m_pows.release()
return 0
def acquire(self, id_mutex, vector):
enter = False
common.updateVector(vector, 0)
common.updateList()
if common.acquire == True:
common.updateMessageList(vector, message_type.ACQUIRE)
common.m_list.acquire()
try:
for a in common.g_acquire_list:
if a[1] == '1':
enter = False
else:
enter = True
finally:
common.m_list.release()
return enter
def release(self, id_mutex, port):
return common.release(port)
def write(self, pos, value):
common.m_shared.acquire()
try:
#common.g_acquire_list[pos][1] = value
common.shared_list.append(value)
finally:
common.m_shared.release()
return True
def read(self, pos):
common.m_shared.acquire()
try:
#pos = common.g_acquire_list.index(value)
value = common.shared_list[pos]
finally:
common.m_shared.release()
return value
#value = [port, dest_port, pos, value, vector]
def requestToWrite(self, vector, value):
if common.write == True:
common.updateMessageList(vector, common.message_type.WRITE)
value.append(common.message_type.WRITE)
common.m_list.acquire()
try:
common.control_list.append(value)
finally:
common.m_list.release()
return True
def requestToRead(self, vector, value):
if common.read == True:
common.updateMessageList(vector, common.message_type.READ)
value.append(common.message_type.READ)
common.m_list.acquire()
try:
common.control_list.append(value)
finally:
common.m_list.release()
return True
self.server.register_instance(Functions())
def stop(self):
self.server.shutdown()
def run(self):
print "Starting " + self.name
self.server.serve_forever()
print "Exiting " + self.name
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument("-H",
"--host",
default="",
help="interface to serve rpc from")
parser.add_argument("-p",
"--port",
default=8000,
help="increase output verbosity")
args = parser.parse_args()
logger = logging.getLogger('xmlrpc')
logger.setLevel(logging.ERROR)
LOG_TO_FILE = False
if LOG_TO_FILE:
# create a file handler
handler = logging.FileHandler('xmlrpc.log')
handler.setLevel(logging.INFO)
# create a logging format
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
# add the handlers to the logger
logger.addHandler(handler)
# Create server
server = SimpleXMLRPCServer((args.host, args.port),
requestHandler=RequestHandler)
server.register_introspection_functions()
class MyListener(object):
def __init__(self):
self.directory = {}
def remove_service(self, zeroconf, type, name):
if name in self.directory:
print("Service %s removed" % (name, ))
del self.directory[name]
def add_service(self, zeroconf, type, name):
if 'axcend.bridge' in name:
info = zeroconf.get_service_info(type, name)
if info:
address = "{}".format(socket.inet_ntoa(info.address))
print("Service %s added (%s)" % (name, address))
self.directory[name] = {'addr': address, 'port': info.port}
zero = zeroconf.Zeroconf()
listener = MyListener()
browser = zeroconf.ServiceBrowser(zero, '_http._tcp.local.', listener)
class MyFuncs:
def __init__(self):
Controller.gotoApplication()
self.ser = None
path = '/dev/ttyACM.axcend'
if os.path.exists(path):
self.ser = serial.Serial(path, timeout=0, write_timeout=0)
if self.ser is None:
raise Exception('unable to locate /dev/ttyACM*')
self.logger = logging.getLogger('xmlrpc')
def reset(self):
self.logger.info('RESET')
self.ser.reset_input_buffer()
self.ser.reset_output_buffer()
return True
def echo(self, data):
return data
def list(self):
results = []
for name in listener.directory:
item = {
'name': name,
'addr': listener.directory[name]['addr'],
'port': listener.directory[name]['port']
}
results.append(item)
return results
def write(self, data):
def bytes(s):
return ''.join(chr(x) for x in s)
self.logger.error('WRITE {}'.format(data))
retries = 2
while retries:
try:
self.ser.write(b'{}'.format(bytes(data)))
self.ser.flush()
except:
self.logger.info('WRITE failure')
if self.ser is not None:
self.ser.close()
self.__init__()
else:
break
finally:
retries -= 1
return True
def read(self):
retries = 2
while retries:
try:
data = [ord(x) for x in self.ser.read(2048)]
self.logger.info('READ {}'.format(data))
except:
self.logger.info('READ failure')
if self.ser is not None:
self.ser.close()
self.__init__()
else:
return data
finally:
retries -= 1
return []
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.ser.close()
with MyFuncs() as myfuncs:
try:
server.register_instance(myfuncs)
except serial.serialutil.SerialException, e:
print(e)
return -1
# Run the server's main loop
try:
server.serve_forever()
except KeyboardInterrupt:
pass
finally:
server.shutdown()
zeroconf.close()
class MinionSim(threading.Thread):
def __init__(self, config_dir, count, osds_per_host, port=8761, prefix=PREFIX, domain=DOMAIN):
super(MinionSim, self).__init__()
self._config_dir = config_dir
self._count = count
self._server = None
self._server_available = threading.Event()
self.minions = {}
def get_dns(index):
host = "{0}{1:03d}".format(prefix, index)
return host, "{0}.{1}".format(host, domain)
config_file = os.path.join(self._config_dir, 'cluster.json')
self.cluster = CephCluster(config_file)
if not os.path.exists(config_file):
self.cluster.create([get_dns(i)[1] for i in range(0, self._count)], osds_per_host=osds_per_host)
self.cluster.save()
# An XMLRPC service for the minions' fake ceph plugins to
# get their state
self._server = SimpleXMLRPCServer(("localhost", port), allow_none=True)
self._server.register_instance(self.cluster)
rpc_url = "http://localhost:%s" % port
for i in range(0, self._count):
hostname, fqdn = get_dns(i)
self.minions[fqdn] = MinionLauncher(rpc_url, self._config_dir, hostname, fqdn, self.cluster)
# Quick smoke test that these methods aren't going
# to throw exceptions (rather stop now than get exceptions
# remotely)
for minion in self.minions.values():
self.cluster.get_stats(minion.fqdn)
def get_minion_fqdns(self):
return [m.fqdn for m in self.minions.values()]
def start(self):
super(MinionSim, self).start()
self._server_available.wait()
def run(self):
# A thread to generate some synthetic activity on the synthetic cluster
load_gen = LoadGenerator(self.cluster)
load_gen.start()
self.start_minions()
self._server_available.set()
log.debug("Starting XMLRPC server...")
self._server.serve_forever()
self._server.server_close()
log.debug("XMLRPC server terminated, stopping threads")
log.debug("Stopping load gen")
load_gen.stop()
load_gen.join()
log.debug("Stopping minions")
self.halt_minions()
log.debug("Saving state")
self.cluster.save()
log.debug("Complete.")
def stop(self):
# FIXME should stop the minions before the XMLRPC server, because otherwise
# minions start getting XMLRPC errors
self._server.shutdown()
def halt_minions(self):
for minion in self.minions.values():
minion.stop()
for minion in self.minions.values():
minion.join()
def start_minions(self):
for minion in self.minions.values():
minion.start()
def halt_minion(self, minion_id):
self.minions[minion_id].stop()
self.minions[minion_id].join()
def start_minion(self, minion_id):
self.minions[minion_id].start()
class CIOMSSimulatorServer(object):
"""
Dispatches an CIOMSSimulator with a SimpleXMLRPCServer.
Intended to be run outside of pyon.
"""
def __init__(self, host, port, inactivity_period=None):
"""
Creates a SimpleXMLRPCServer and starts a Thread where serve_forever
is called on the server.
@param host Hostname for the service
@param port Port for the service
"""
self._running = True
self._sim = CIOMSSimulatorWithExit(self)
if log.isEnabledFor(logging.DEBUG):
ser = NetworkUtil.serialize_network_definition(self._sim._ndef)
log.debug("network serialization:\n %s" %
ser.replace('\n', '\n '))
log.debug("network.get_map() = %s\n" %
self._sim.config.get_platform_map())
self._server = SimpleXMLRPCServer((host, port), allow_none=True)
actual_port = self._server.socket.getsockname()[1]
uri = "http://%s:%s/" % (host, actual_port)
# write the URI to a file for launching process to see it:
with open("logs/rsn_oms_simulator.yml", 'w') as f:
f.write("rsn_oms_simulator_uri=%s\n" % uri)
self._server.register_introspection_functions()
self._server.register_instance(self._sim, allow_dotted_names=True)
log.info("Methods:\n\t%s",
"\n\t".join(self._server.system_listMethods()))
self._check_pyon()
runnable = Thread(target=self._server.serve_forever)
runnable.setDaemon(True)
runnable.start()
log.info("OMS simulator xmlrpc server listening on %s" % uri)
if inactivity_period:
self._sim.x_exit_inactivity(inactivity_period)
def shutdown_server(self):
self._running = False
if self._sim:
log.info("RSN OMS simulator exiting...")
self._sim = None
self._server.shutdown()
self._server = None
def wait_until_shutdown(self):
while self._running:
time.sleep(1)
self.shutdown_server()
@staticmethod
def _check_pyon():
"""
Prints a warning message if pyon is detected.
"""
if 'pyon' in sys.modules:
m = "!! WARNING: pyon in sys.modules !!"
s = "!" * len(m)
sys.stderr.write("\n%s\n%s\n%s\n\n" % (s, m, s))
class BattleNode(object):
def __init__(self, addr):
self.addr = addr
self.position = random_pair()
self._victim = None
self._victim_addr = None
self._victim_lock = Lock()
self.lost = Event()
self.server = RPCServer(addr,requestHandler=SilentRPCHandler)
self.server.register_function(self.defend, 'defend')
self.server.register_function(self.insert, 'insert')
self.server.register_function(self.ping, 'ping')
self.server_thread = Thread(target=self.server.serve_forever)
self.server_thread.daemon = True
self.server_thread.start()
self.fail_over = None
self.loop_event = Event()
self.loop_thread = Thread(target=self.ping_loop)
self.loop_thread.daemon = True
self.loop_thread.start()
def __eq__(self, other):
return self.addr == other.addr
def __ne__(self, other):
return self.addr != other.addr
def stop(self):
self.loop_event.clear()
self.loop_thread.join()
self.server.shutdown()
self.server_thread.join()
@property
def victim(self):
return self._victim_addr
@victim.setter
def victim(self, val):
self._victim_addr = val
self._victim = ServerProxy('http://{}:{}'.format(*val))
self.loop_event.set()
def attack(self, pos=None):
if pos is None:
pos = random_pair()
with self._victim_lock:
new_victim = tuple(self._victim.defend(pos))
if new_victim != self.victim:
self.victim = new_victim
return True
return False
def defend(self, pos):
if tuple(pos) == self.position:
self.lost.set()
return self._victim_addr
return self.addr
def insert(self, addr):
with self._victim_lock:
old_victim = self._victim_addr
self.victim = tuple(addr)
return old_victim
def join(self, addr):
attacker = ServerProxy('http://{}:{}'.format(*addr))
with self._victim_lock:
self.victim = tuple(attacker.insert(self.addr))
def ping(self):
if self.victim:
return self.victim
return self.addr
def ping_victim(self):
if self.victim:
try:
fail_over = tuple(self._victim.ping())
if fail_over != self.victim:
self.fail_over = fail_over
except IOError:
if self.loop_event.is_set():
self.victim = self.fail_over
def ping_loop(self):
self.loop_event.wait()
while self.loop_event.is_set():
time.sleep(0.1)
with self._victim_lock:
self.ping_victim()
class LTLMoPClient(object):
def __init__(self, handler_port, chat_callback):
self.CONFIG = Config()
self.handler_port = handler_port
self.map_bitmap = None
self.robot_pos = None
self.fiducial_positions = {}
self.chat_callback = chat_callback
# To be set by load_project
self.proj = None
self.executor_proxy = None
self.dialogue_manager = None
self.load_project(False)
def load_project(self, reloading):
"""Load a project from CONFIG.spec_file, reusing the proxy if reloading."""
spec_file = self.CONFIG.get_spec_file()
self.proj = project.Project()
self.proj.loadProject(spec_file)
# Set the compiler to give structured responses
self.proj.compile_options["slurp_struct_responses"] = True
if not reloading:
self.executor_proxy = self.get_executor(spec_file)
else:
self.executor_proxy.initialize(spec_file, None)
self.dialogue_manager = self.get_dialogue_manager()
def get_dialogue_manager(self):
# Start dialogue manager
dialogue_manager = BarebonesDialogueManager(self, self.executor_proxy)
self.user_name = "User"
# Wait for executor to fully boot
self.append_log(">> Please wait, initializing...")
while not self.executor_ready_flag.wait(0.1):
time.sleep(.1)
self.append_log(">> Ready!")
self.append_log(" ")
# Tell the user we are ready
self.append_log("Hello.", "System")
return dialogue_manager
def get_executor(self, spec_file):
# Start execution context
print "Starting executor..."
self.executor_ready_flag = threading.Event()
self.executor_port = find_port(self.CONFIG.executor_base_port)
print "Using port {} for executor".format(self.executor_port)
self.executor_process = multiprocessing.Process(
target=execute.execute_main,
args=(self.executor_port, spec_file, None, False, {
'handler_port': self.handler_port
}))
self.executor_process.start()
# Start our own xml-rpc server to receive events from execute
self.server_port = find_port(self.CONFIG.ltlmop_base_port)
print "Using port {} for LTLMoP client".format(self.server_port)
self.xmlrpc_server = SimpleXMLRPCServer(
("127.0.0.1", self.server_port),
logRequests=False,
allow_none=True)
# Register functions with the XML-RPC server
self.xmlrpc_server.register_function(self.handleEvent)
# Kick off the XML-RPC server thread
self.xmlrpc_server_thread = threading.Thread(
target=self.xmlrpc_server.serve_forever)
self.xmlrpc_server_thread.daemon = True
self.xmlrpc_server_thread.start()
print "LTLMoPClient listening for XML-RPC calls on \
http://127.0.0.1:{} ...".format(self.server_port)
# Connect to executor
print "Connecting to executor...",
while True:
try:
executor_proxy = xmlrpclib.ServerProxy(
"http://127.0.0.1:{}".format(self.executor_port),
allow_none=True)
# Register with executor for event callbacks
executor_proxy.registerExternalEventTarget(
"http://127.0.0.1:{}".format(self.server_port))
except socket.error:
sys.stdout.write(".")
else:
break
print
return executor_proxy
def set_project(self, specfile):
"""Set the project of this client via a new specfile"""
self.CONFIG.base_spec = specfile
self.load_project(True)
def handleEvent(self, event_type, event_data):
"""Processes messages from the controller, and updates the GUI accordingly"""
if event_type in ["FREQ"]: # Events to ignore
pass
elif event_type == "POSE":
self.robot_pos = event_data
elif event_type == "FID":
if event_data[1] is None:
# Hide the fiducial
del self.fiducial_positions[event_data[0]]
else:
# Update fiducial position
self.fiducial_positions[event_data[0]] = event_data[1:]
elif event_type == "MESSAGE":
# Provide a way for any part of LTLMoP to give feedback
self.append_log(event_data, "System")
elif event_type == "READY":
self.executor_ready_flag.set()
else:
print "[{}] {}".format(event_type, event_data)
def shutdown(self):
print "Shutting down executor..."
try:
self.executor_proxy.shutdown()
except socket.error:
# Executor probably crashed
pass
self.xmlrpc_server.shutdown()
self.xmlrpc_server_thread.join()
print "Waiting for executor to quit..."
print "(If this takes more than 5 seconds it has crashed and \
you will need to run `killall python` for now)"
self.executor_process.join(5)
# After ten seconds, just kill it
if self.executor_process.is_alive():
self.executor_process.terminate()
print "Executor did not exit in time and was executed."
else:
print "Executor exited normally."
def append_log(self, message, agent=None):
message = str(message)
if agent:
print agent + " : " + message
else:
print message
def get_pragbot_input(self,
user_text): # wxGlade: LTLMoPClient.<event_handler>
# echo
self.append_log(user_text, self.user_name)
# response
if self.dialogue_manager is None:
self.append_log("Dialogue manager not initialized", "!!! Error")
else:
try:
reply = self.dialogue_manager.tell(user_text)
except Parser.ParseErrors:
self.append_log("LTLParser encountered an error.")
reply = self.dialogue_manager.interpreter.CRASH
except IOError:
self.append_log("Could not connect to NLPipeline.")
raise
else:
if type(reply) == list:
for w in reply:
self.on_receive_reply(w)
else:
self.on_receive_reply(reply)
def on_receive_reply(self, result):
""" when the dialoguemanager has gotten back to us """
if result:
self.chat_callback(result)
self.append_log(result, "System")
class RPCAdmin:
# Threaded mix-in
class AsyncXMLRPCServer(SocketServer.ThreadingMixIn, SimpleXMLRPCServer):
pass
admin_ip = "169.254.35.100"
admin_port = 8000
agents_wired = [[1, "169.254.35.101", 8000], [2, "169.254.35.102", 8000],
[3, "169.254.35.103", 8000], [4, "169.254.35.104", 8000],
[6, "169.254.35.105", 8000], [7, "169.254.35.106", 8000],
[8, "169.254.35.107", 8000], [10, "169.254.35.108", 8000],
[12, "169.254.35.109", 8000], [13, "169.254.35.110", 8000],
[14, "169.254.35.101", 8001], [15, "169.254.35.102", 8001],
[16, "169.254.35.103", 8001], [17, "169.254.35.104", 8001],
[18, "169.254.35.105", 8001], [19, "169.254.35.106", 8001],
[20, "169.254.35.107", 8001], [21, "169.254.35.109", 8001],
[22, "169.254.35.110", 8001], [23, "169.254.35.108", 8001],
[24, "169.254.35.101", 8002], [25, "169.254.35.102", 8002],
[26, "169.254.35.103", 8002], [27, "169.254.35.104", 8002],
[28, "169.254.35.106", 8002], [29, "169.254.35.105", 8002],
[30, "169.254.35.107", 8002], [31, "169.254.35.110", 8002]]
#
agents_wireless = [[1, "192.168.1.101", 8000], [2, "192.168.1.102", 8000],
[3, "192.168.1.103", 8000], [4, "192.168.1.104", 8000],
[6, "192.168.1.105", 8000], [7, "192.168.1.106", 8000],
[8, "192.168.1.107", 8000], [10, "192.168.1.108", 8000],
[12, "192.168.1.109",
8000], [13, "192.168.1.110", 8000],
[14, "192.168.1.101",
8001], [15, "192.168.1.102", 8001],
[16, "192.168.1.103",
8001], [17, "192.168.1.104", 8001],
[18, "192.168.1.105",
8001], [19, "192.168.1.106", 8001],
[20, "192.168.1.107",
8001], [21, "192.168.1.109", 8001],
[22, "192.168.1.110",
8001], [23, "192.168.1.108", 8001],
[24, "192.168.1.101",
8002], [25, "192.168.1.102", 8002],
[26, "192.168.1.103",
8002], [27, "192.168.1.104", 8002],
[28, "192.168.1.106",
8002], [29, "192.168.1.105", 8002],
[30, "192.168.1.107", 8002],
[31, "192.168.1.110", 8002]]
#
def __init__(self, ex):
# keep a reference to the gui
self.ex = ex
# Create the RPC server for the admin
# self.server = self.AsyncXMLRPCServer((self.admin_ip, self.admin_port), SimpleXMLRPCRequestHandler,
# logRequests=False)
self.server = SimpleXMLRPCServer((self.admin_ip, self.admin_port),
SimpleXMLRPCRequestHandler,
logRequests=False)
self.server.register_introspection_functions()
# register the functions that can be called remotely
self.server.register_function(self.agent_online, 'agent_online')
self.server.register_function(self.agent_offline, 'agent_offline')
self.server.register_function(self.agent_started_admm,
'agent_started_admm')
self.server.register_function(self.agent_finished_admm,
'agent_finished_admm')
self.server.register_function(self.agent_measurements,
'agent_measurements')
self.server.register_function(self.agent_general_use_message,
'agent_general_use_message')
# start the RPC server
t = threading.Thread(target=self.server.serve_forever)
t.start()
# the communication scenario to be used by default by the agents
self.comm_scenario = "wired_default"
self.agents = self.agents_wired
def agent_online(self, a_id):
self.ex.agent_connected(a_id)
return 1
def agent_offline(self, a_id):
self.ex.agent_disconnected(a_id)
return 1
def agent_started_admm(self, a_id):
self.ex.agent_running_admm(a_id)
self.v_opt = {}
return 1
def agent_finished_admm(self, ano, dt_opt, dt_rpc, v_ref, p_ref):
self.ex.agent_finished_admm(ano, dt_opt, dt_rpc, v_ref, p_ref)
self.v_opt[ano] = [v_ref, p_ref]
return 1
def print_results(self):
s_keys = sorted(self.v_opt)
volt = []
power = []
for key in s_keys:
volt.append(self.v_opt[key][0])
power.append(self.v_opt[key][1])
return 'v_d = ' + str(volt) + "'; \n p_d = " + str(power) + "';"
def agent_measurements(self, ano, dt_opal, v_meas, p_meas, trip):
self.ex.agent_update_values(ano, dt_opal, v_meas, p_meas, trip)
return 1
def agent_general_use_message(self, ano, message):
print("Agent " + str(ano) + ":" + message)
return 1
def disconnect(self):
print("=====Shuting down RPC server")
self.server.shutdown()
def set_communication(self, comm_type):
if "wired" in comm_type:
self.agents = self.agents_wired
else:
self.agents = self.agents_wireless
def say_to_agent(self, id, s):
if s is "STOP":
for a in self.agents:
if a[0] == id:
srv_addr = "http://" + a[1] + ":" + str(a[2])
print("asking agent " + str(id) + " to shut down at " +
srv_addr)
agent = xmlrpclib.ServerProxy(srv_addr)
try:
agent.remote_shutdown()
except Exception as exc:
print("Cannot talk to agent " + str(id))
def say_to_all_agents(self, s):
if s is "STOP":
for a in self.agents:
srv_addr = "http://" + a[1] + ":" + str(a[2])
agent = xmlrpclib.ServerProxy(srv_addr)
try:
agent.remote_shutdown()
except (socket_error, xmlrpclib.Fault, xmlrpclib.ProtocolError,
xmlrpclib.ResponseError), exc:
print("Cannot talk to agent " + str(a[0]))
elif s is "START ADMM":
# for a in self.agents:
# srv_addr = "http://" + a[1] + ":" + str(a[2])
# agent = xmlrpclib.ServerProxy(srv_addr)
# agent.start_admm()
srv_addr = "http://" + self.agents[0][1] + ":" + str(
self.agents[0][2])
agent = xmlrpclib.ServerProxy(srv_addr)
agent.start_admm()
class SimGUI_Frame(wx.Frame):
def __init__(self, *args, **kwds):
# begin wxGlade: SimGUI_Frame.__init__
kwds["style"] = wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, *args, **kwds)
self.window_1 = wx.SplitterWindow(self, -1, style=wx.SP_3D|wx.SP_BORDER|wx.SP_LIVE_UPDATE)
self.window_1_pane_2 = wx.Panel(self.window_1, -1)
self.notebook_1 = wx.Notebook(self.window_1_pane_2, -1, style=0)
self.notebook_1_pane_2 = wx.Panel(self.notebook_1, -1)
self.notebook_1_pane_1 = wx.Panel(self.notebook_1, -1)
self.window_1_pane_1 = wx.Panel(self.window_1, -1)
self.text_ctrl_sim_log = wx.richtext.RichTextCtrl(self.notebook_1_pane_1, -1, "", style=wx.TE_MULTILINE|wx.TE_READONLY)
self.text_ctrl_slurpout = wx.richtext.RichTextCtrl(self.notebook_1_pane_2, -1, "", style=wx.TE_MULTILINE|wx.TE_READONLY)
self.text_ctrl_slurpin = wx.TextCtrl(self.notebook_1_pane_2, -1, "", style=wx.TE_PROCESS_ENTER)
self.button_SLURPsubmit = wx.Button(self.notebook_1_pane_2, -1, "Submit")
self.button_sim_startPause = wx.Button(self.window_1_pane_2, -1, "Start")
self.button_sim_log_clear = wx.Button(self.window_1_pane_2, -1, "Clear Log")
self.button_sim_log_export = wx.Button(self.window_1_pane_2, -1, "Export Log...")
self.label_1 = wx.StaticText(self.window_1_pane_2, -1, "Show log messages for:")
self.checkbox_statusLog_targetRegion = wx.CheckBox(self.window_1_pane_2, -1, "Target region announcements")
self.checkbox_statusLog_propChange = wx.CheckBox(self.window_1_pane_2, -1, "System proposition changes")
self.checkbox_statusLog_border = wx.CheckBox(self.window_1_pane_2, -1, "Region border crossings")
self.checkbox_statusLog_other = wx.CheckBox(self.window_1_pane_2, -1, "Other debugging messages")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_TEXT_ENTER, self.onSLURPSubmit, self.text_ctrl_slurpin)
self.Bind(wx.EVT_BUTTON, self.onSLURPSubmit, self.button_SLURPsubmit)
self.Bind(wx.EVT_BUTTON, self.onSimStartPause, self.button_sim_startPause)
self.Bind(wx.EVT_BUTTON, self.onSimClear, self.button_sim_log_clear)
self.Bind(wx.EVT_BUTTON, self.onSimExport, self.button_sim_log_export)
self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGED, self.onResize, self.window_1)
# end wxGlade
self.window_1_pane_1.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
self.mapBitmap = None
self.window_1_pane_1.Bind(wx.EVT_PAINT, self.onPaint)
self.Bind(wx.EVT_ERASE_BACKGROUND, self.onEraseBG)
self.proj = project.Project()
self.proj.setSilent(True)
# Make status bar at bottom.
self.sb = wx.StatusBar(self)
self.SetStatusBar(self.sb)
self.sb.SetFieldsCount(1)
self.sb.SetStatusText("PAUSED")
self.button_sim_log_export.Enable(False)
# Connect to executor
try:
executor_port = int(sys.argv[1])
except ValueError:
print "ERROR: Invalid port '{}'".format(arg)
sys.exit(2)
self.executorProxy = xmlrpclib.ServerProxy("http://127.0.0.1:{}".format(executor_port), allow_none=True)
# Create the XML-RPC server
# Search for a port we can successfully bind to
while True:
listen_port = random.randint(10000, 65535)
try:
self.xmlrpc_server = SimpleXMLRPCServer(("127.0.0.1", listen_port), logRequests=False, allow_none=True)
except socket.error as e:
pass
else:
break
# Register functions with the XML-RPC server
self.xmlrpc_server.register_function(self.handleEvent)
# Kick off the XML-RPC server thread
self.XMLRPCServerThread = threading.Thread(target=self.xmlrpc_server.serve_forever)
self.XMLRPCServerThread.daemon = True
self.XMLRPCServerThread.start()
print "SimGUI listening for XML-RPC calls on http://127.0.0.1:{} ...".format(listen_port)
# Register with executor for event callbacks
self.executorProxy.registerExternalEventTarget("http://127.0.0.1:{}".format(listen_port))
self.robotPos = None
self.robotVel = (0,0)
self.markerPos = None
self.dialogueManager = None
self.currentGoal = None
self.Bind(wx.EVT_CLOSE, self.onClose)
def loadRegionFile(self, filename):
self.proj.rfi = regions.RegionFileInterface()
self.proj.rfi.readFile(filename)
self.Bind(wx.EVT_SIZE, self.onResize, self)
self.onResize()
def loadSpecFile(self, filename):
self.proj.loadProject(filename)
self.hsub = handlerSubsystem.HandlerSubsystem(None, self.proj.project_root)
config, success = self.hsub.loadConfigFile(self.proj.current_config)
if success: self.hsub.configs.append(config)
self.hsub.setExecutingConfig(self.proj.current_config)
self.Bind(wx.EVT_SIZE, self.onResize, self)
if self.proj.compile_options["parser"] == "slurp":
self.initDialogue()
else:
self.notebook_1.DeletePage(1)
self.onResize()
def handleEvent(self, eventType, eventData):
"""
Processes messages from the controller, and updates the GUI accordingly
"""
# Update stuff (should put these in rough order of frequency for optimal speed
if eventType == "FREQ":
wx.CallAfter(self.sb.SetStatusText, "Running at approximately {}Hz...".format(eventData), 0)
elif eventType == "POSE":
self.robotPos = eventData
wx.CallAfter(self.onPaint)
elif eventType == "MARKER":
self.markerPos = eventData
wx.CallAfter(self.onPaint)
elif eventType == "VEL":
# We can't plot anything before we have a map
if self.mapBitmap is None:
print "Received drawing command before map. You probably have an old execute.py process running; please kill it and try again."
return
[x,y] = eventData
[x,y] = map(int, (self.mapScale*x, self.mapScale*y))
self.robotVel = (x, y)
elif eventType == "PAUSE":
wx.CallAfter(self.sb.SetStatusText, "PAUSED.", 0)
elif eventType == "SPEC":
wx.CallAfter(self.loadSpecFile, eventData)
elif eventType == "REGIONS":
wx.CallAfter(self.loadRegionFile, eventData)
else:
if isinstance(eventData, basestring):
if eventData.startswith("Output proposition"):
if self.checkbox_statusLog_propChange.GetValue():
wx.CallAfter(self.appendLog, eventData + "\n", color="GREEN")
elif eventData.startswith("Heading to"):
if self.checkbox_statusLog_targetRegion.GetValue():
wx.CallAfter(self.appendLog, eventData + "\n", color="BLUE")
elif eventData.startswith("Crossed border"):
if self.checkbox_statusLog_border.GetValue():
wx.CallAfter(self.appendLog, eventData + "\n", color="CYAN")
# Detect our current goal index
elif eventData.startswith("Currently pursuing goal"):
m = re.search(r"#(\d+)", eventData)
if m is not None:
self.currentGoal = int(m.group(1))
elif self.checkbox_statusLog_other.GetValue():
if eventData != "":
wx.CallAfter(self.appendLog, eventData + "\n", color="BLACK")
elif self.checkbox_statusLog_other.GetValue():
if eventData != "":
wx.CallAfter(self.appendLog, str(eventData) + "\n", color="BLACK")
def __set_properties(self):
# begin wxGlade: SimGUI_Frame.__set_properties
self.SetTitle("Simulation Status")
self.SetSize((836, 713))
self.button_SLURPsubmit.SetDefault()
self.checkbox_statusLog_targetRegion.SetValue(1)
self.checkbox_statusLog_propChange.SetValue(1)
self.checkbox_statusLog_border.SetValue(1)
self.checkbox_statusLog_other.SetValue(1)
# end wxGlade
def __do_layout(self):
# begin wxGlade: SimGUI_Frame.__do_layout
sizer_1 = wx.BoxSizer(wx.VERTICAL)
sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
sizer_5 = wx.BoxSizer(wx.HORIZONTAL)
sizer_43_copy_1 = wx.BoxSizer(wx.VERTICAL)
sizer_3 = wx.BoxSizer(wx.VERTICAL)
sizer_43_copy_copy = wx.BoxSizer(wx.VERTICAL)
sizer_6 = wx.BoxSizer(wx.VERTICAL)
sizer_7 = wx.BoxSizer(wx.HORIZONTAL)
sizer_4 = wx.BoxSizer(wx.HORIZONTAL)
sizer_5.Add((5, 30), 0, 0, 0)
sizer_43_copy_copy.Add((20, 5), 0, 0, 0)
sizer_4.Add(self.text_ctrl_sim_log, 1, wx.ALL|wx.EXPAND, 5)
self.notebook_1_pane_1.SetSizer(sizer_4)
sizer_6.Add(self.text_ctrl_slurpout, 1, wx.ALL|wx.EXPAND, 5)
sizer_7.Add(self.text_ctrl_slurpin, 1, wx.ALL|wx.EXPAND, 5)
sizer_7.Add(self.button_SLURPsubmit, 0, wx.ALL, 5)
sizer_6.Add(sizer_7, 0, wx.EXPAND, 0)
self.notebook_1_pane_2.SetSizer(sizer_6)
self.notebook_1.AddPage(self.notebook_1_pane_1, "Status Log")
self.notebook_1.AddPage(self.notebook_1_pane_2, "SLURP Dialogue")
sizer_43_copy_copy.Add(self.notebook_1, 1, wx.EXPAND, 0)
sizer_43_copy_copy.Add((20, 5), 0, 0, 0)
sizer_5.Add(sizer_43_copy_copy, 6, wx.EXPAND, 0)
sizer_5.Add((20, 30), 0, 0, 0)
sizer_43_copy_1.Add((20, 20), 0, 0, 0)
sizer_43_copy_1.Add(self.button_sim_startPause, 0, wx.LEFT|wx.RIGHT|wx.EXPAND|wx.ALIGN_CENTER_HORIZONTAL, 20)
sizer_43_copy_1.Add((20, 10), 0, 0, 0)
sizer_43_copy_1.Add(self.button_sim_log_clear, 0, wx.LEFT|wx.RIGHT|wx.EXPAND|wx.ALIGN_CENTER_HORIZONTAL, 20)
sizer_43_copy_1.Add((20, 10), 0, 0, 0)
sizer_43_copy_1.Add(self.button_sim_log_export, 0, wx.LEFT|wx.RIGHT|wx.EXPAND|wx.ALIGN_CENTER_HORIZONTAL, 20)
sizer_43_copy_1.Add((20, 10), 0, 0, 0)
sizer_3.Add((20, 20), 0, 0, 0)
sizer_3.Add(self.label_1, 0, 0, 0)
sizer_3.Add(self.checkbox_statusLog_targetRegion, 0, wx.TOP|wx.BOTTOM, 5)
sizer_3.Add(self.checkbox_statusLog_propChange, 0, wx.TOP|wx.BOTTOM, 5)
sizer_3.Add(self.checkbox_statusLog_border, 0, wx.TOP|wx.BOTTOM, 5)
sizer_3.Add(self.checkbox_statusLog_other, 0, wx.TOP|wx.BOTTOM, 5)
sizer_43_copy_1.Add(sizer_3, 1, wx.EXPAND, 0)
sizer_5.Add(sizer_43_copy_1, 3, wx.EXPAND, 0)
sizer_5.Add((20, 30), 0, 0, 0)
self.window_1_pane_2.SetSizer(sizer_5)
self.window_1.SplitHorizontally(self.window_1_pane_1, self.window_1_pane_2)
sizer_2.Add(self.window_1, 1, wx.EXPAND, 0)
sizer_2.Add((20, 20), 0, 0, 0)
sizer_1.Add(sizer_2, 1, wx.EXPAND, 0)
self.SetSizer(sizer_1)
self.Layout()
# end wxGlade
self.window_1.SetSashPosition(self.GetSize().y/2)
self.window_1_pane_1.SetBackgroundColour(wx.WHITE)
def onResize(self, event=None): # wxGlade: SimGUI_Frame.<event_handler>
size = self.window_1_pane_1.GetSize()
self.mapBitmap = wx.EmptyBitmap(size.x, size.y)
self.mapScale = mapRenderer.drawMap(self.mapBitmap, self.proj.rfi, scaleToFit=True, drawLabels=mapRenderer.LABELS_ALL_EXCEPT_OBSTACLES, memory=True)
self.Refresh()
self.Update()
if event is not None:
event.Skip()
def onEraseBG(self, event):
# Avoid unnecessary flicker by intercepting this event
pass
def onPaint(self, event=None):
if self.mapBitmap is None:
return
if event is None:
dc = wx.ClientDC(self.window_1_pane_1)
else:
pdc = wx.AutoBufferedPaintDC(self.window_1_pane_1)
try:
dc = wx.GCDC(pdc)
except:
dc = pdc
dc.BeginDrawing()
# Draw background
dc.DrawBitmap(self.mapBitmap, 0, 0)
# Draw robot
if self.robotPos is not None:
[x,y] = map(lambda x: int(self.mapScale*x), self.robotPos)
dc.DrawCircle(x, y, 5)
if self.markerPos is not None:
[m,n] = map(lambda m: int(self.mapScale*m), self.markerPos)
dc.SetBrush(wx.Brush(wx.RED))
dc.DrawCircle(m, n, 5)
# Draw velocity vector of robot (for debugging)
#dc.DrawLine(self.robotPos[0], self.robotPos[1],
# self.robotPos[0] + self.robotVel[0], self.robotPos[1] + self.robotVel[1])
dc.EndDrawing()
if event is not None:
event.Skip()
def appendLog(self, text, color="BLACK"):
# for printing everything on the log
# annotate any pXXX region names with their human-friendly name
# convert to set to avoid infinite explosion
for p_reg in set(re.findall(r'\b(p\d+)\b',text)):
for rname, subregs in self.proj.regionMapping.iteritems():
if p_reg in subregs:
break
text = re.sub(r'\b'+p_reg+r'\b', '%s (%s)' % (p_reg, rname), text)
self.text_ctrl_sim_log.SetInsertionPointEnd()
self.text_ctrl_sim_log.BeginTextColour(color)
self.text_ctrl_sim_log.WriteText("["+time.strftime("%H:%M:%S")+"] "+text)
self.text_ctrl_sim_log.EndTextColour()
self.text_ctrl_sim_log.ShowPosition(self.text_ctrl_sim_log.GetLastPosition())
self.text_ctrl_sim_log.Refresh()
def onSimStartPause(self, event): # wxGlade: SimGUI_Frame.<event_handler>
btn_label = self.button_sim_startPause.GetLabel()
if btn_label == "Start" or btn_label == "Resume":
self.button_sim_log_export.Enable(False)
self.executorProxy.resume()
self.appendLog("%s!\n" % btn_label,'GREEN')
self.button_sim_startPause.SetLabel("Pause")
else:
self.executorProxy.pause()
self.appendLog('Pause...\n','RED')
self.button_sim_log_export.Enable(True)
self.button_sim_startPause.SetLabel("Resume")
self.Refresh()
event.Skip()
def onSimExport(self, event): # wxGlade: SimGUI_Frame.<event_handler>
"""
Ask the user for a filename to save the Log as, and then save it.
"""
default = 'StatusLog'
# Get a filename
fileName = wx.FileSelector("Save File As",
os.path.join(os.getcwd(),'examples'),
default_filename=default,
default_extension="txt",
wildcard="Status Log files (*.txt)|*.txt",
flags = wx.SAVE | wx.OVERWRITE_PROMPT)
if fileName == "": return # User cancelled.
# Force a .txt extension. How mean!!!
if os.path.splitext(fileName)[1] != ".txt":
fileName = fileName + ".txt"
# Save data to the file
self.saveFile(fileName)
event.Skip()
def saveFile(self, fileName):
"""
Write all data out to a file.
"""
if fileName is None:
return
f = open(fileName,'w')
print >>f, "Experiment Status Log"
print >>f
# write the log
print >>f, str(self.text_ctrl_sim_log.GetValue())
f.close()
def onClose(self, event):
msg = wx.BusyInfo("Please wait, shutting down...")
try:
self.executorProxy.shutdown()
except socket.error:
# Executor probably crashed
pass
self.xmlrpc_server.shutdown()
self.XMLRPCServerThread.join()
#time.sleep(2)
event.Skip()
def onSimClear(self, event): # wxGlade: SimGUI_Frame.<event_handler>
self.text_ctrl_sim_log.Clear()
event.Skip()
def initDialogue(self):
# Add SLURP to path for import
p = os.path.dirname(os.path.abspath(__file__))
sys.path.append(os.path.join(p, "..", "etc", "SLURP"))
from ltlbroom.specgeneration import SpecGenerator
_SLURP_SPEC_GENERATOR = SpecGenerator()
# Filter out regions it shouldn't know about
filtered_regions = [region.name for region in self.proj.rfi.regions
if not (region.isObstacle or region.name.lower() == "boundary")]
sensorList = copy.deepcopy(self.proj.enabled_sensors)
robotPropList = self.proj.enabled_actuators + self.proj.all_customs
text = self.proj.specText
LTLspec_env, LTLspec_sys, self.proj.internal_props, internal_sensors, results, responses, traceback = \
_SLURP_SPEC_GENERATOR.generate(text, sensorList, filtered_regions, robotPropList,
self.hsub.executing_config.region_tags)
from ltlbroom.dialog import DialogManager
self.dialogueManager = DialogManager(traceback)
def onSLURPSubmit(self, event): # wxGlade: SimGUI_Frame.<event_handler>
if self.text_ctrl_slurpin.GetValue() == "":
event.Skip()
return
user_text = self.text_ctrl_slurpin.GetValue()
# echo
self.text_ctrl_slurpout.BeginBold()
self.text_ctrl_slurpout.AppendText("User: "******"\n")
self.text_ctrl_slurpout.ShowPosition(self.text_ctrl_slurpout.GetLastPosition())
self.text_ctrl_slurpout.Refresh()
self.text_ctrl_slurpin.Clear()
# response
if self.dialogueManager is None:
self.text_ctrl_slurpout.BeginBold()
self.text_ctrl_slurpout.AppendText("Error: Dialogue Manager not initialized")
self.text_ctrl_slurpout.EndBold()
else:
sys_text = self.dialogueManager.tell(user_text, self.currentGoal)
self.text_ctrl_slurpout.BeginBold()
self.text_ctrl_slurpout.AppendText("System: ")
self.text_ctrl_slurpout.EndBold()
self.text_ctrl_slurpout.AppendText(sys_text + "\n")
self.text_ctrl_slurpout.ShowPosition(self.text_ctrl_slurpout.GetLastPosition())
self.text_ctrl_slurpout.Refresh()
event.Skip()
class Backdoor(threading.Thread):
'''
Sets up an xmlrpc server to handle requests from a concert master to joint.
This will usually get installed directly into the app managers.
Important variables that should be visible to users of this class
@var concert_master - zeroconf details for the concert master
@var robot_namespace - namespace that apps must be launched under
@var port - port that the xmrpc backdoor is running on
@arg platform_info : contains the platform-system-robot triple, key and suggested_name
@arg whitelist/blacklist : internally to help the backdoor decide whether to serve a specific concert master or not
@arg receive_invitation_callback : used when the backdoor receives an invitation.
'''
def __init__(self, platform_info, whitelist, blacklist, receive_invitation_callback):
threading.Thread.__init__(self)
# Visible variables
self.concert_master = None
self.robot_namespace = None
self.port = 0
self._server = None
self._unique_names = {} # pairs concert masters with unique names provided by the concert masters
# System-Platform-Robot triple : first and second are fixed, third is variable (ros.linux.*)
# Key : unique id generated by uuid
# Suggested Name : this is the hint given to the concert from which the concert will generate a
# unique name and pass back
self.platform_info = platform_info
# These allow for some decision logic when accepting invitations from concert masters
self._whitelist = whitelist
self._blacklist = blacklist
# Private variables
self._receive_invitation_callback = receive_invitation_callback
# Get server details and an unused port
self.hostname = roslib.network.get_host_name()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(("",0)) # The empty string is equivalent to socket.INADDR_ANY (any network interface on the computer)
self.address,self.port = s.getsockname()
s.close()
# There is a small window here where someone else can grab the unused socket
# so we should really put in checks below to make sure we don't get an error.
# XmlRpc server setup
self._server = SimpleXMLRPCServer(("", self.port)) # The empty hostname string is equivalent to socket.INADDR_ANY (any network interface on the computer)
self._server.register_introspection_functions() # allows a client to do print s.system.listMethods()
self._server.register_function(self.invite, 'invite')
self._server.register_function(self.platform, 'platform')
self._server.register_function(self.system, 'system')
self._server.register_function(self.robot, 'robot')
self._server.register_function(self.key, 'key')
self._server.register_function(self.suggested_name, 'suggested_name')
self._server.register_function(self.unique_name, 'unique_name')
listen_for_concerts()
def run(self):
self._server.serve_forever()
def stop(self):
'''
Shutdown the xmlrpc server, also stop the zeroconf services.
'''
self._server.shutdown()
if self.isAlive():
self.join()
########################################################################
# Backdoor XmlRpc Server Methods
########################################################################
############################
# Platform Info
############################
def system(self):
return self.platform_info.system;
def platform(self):
return self.platform_info.platform;
def robot(self):
return self.platform_info.robot;
def key(self):
return self.platform_info.key;
def suggested_name(self):
return self.platform_info.suggested_name;
def unique_name(self, concert_name, robot_namespace):
'''
Lets the app manager store a unique name to use (at some point in the future)
with the corresponding concert master.
@param concert_name : the zeroconf name for the concert master (have to resolve ip, port against this)
@param robot_namespace : the namespace to expose to the concert (must be unique!)
'''
self._unique_names[concert_name] = robot_namespace
return True
def invite(self, concert_name):
'''
Server's callback function for handling invitation requests.
@param concert_name : the zeroconf name for the concert master (have to resolve ip, port against this)
'''
######################
# Whitelist/Blacklist
######################
rospy.loginfo("App Manager: received an invitation from '%s'."%concert_name)
if self._whitelist: # wwhitelists have priority
if not concert_name in self._whitelist:
rospy.loginfo("App Manager: refusing an invitation as we are using a whitelist and '%s' is not whitelisted."%concert_name)
return False
else:
if self._blacklist:
if concert_name in self._blacklist:
rospy.loginfo("App Manager: refusing an invitation as '%s' is blacklisted."%concert_name)
return False
######################
# Discovery
######################
concerts = discover_concerts()
concert_master = None
for concert in concerts:
if concert.name == concert_name:
# Do we need to debug this further (i.e. check its resolved?)
rospy.logdebug("App Manager: found the concert")
concert_master = concert
break
if concert_master is None:
rospy.logwarn("App Manager: invitation was from an undiscovered concert [%s]"%concert_name)
return False
# ros masters are currently hooked into ipv4 only.
if len(concert_master.ipv4_addresses) > 0:
concert_address = concert_master.ipv4_addresses[0]
else:
rospy.logwarn("App Manager: invitation was from an unresolvable concert [%s]"%concert_name)
return False
try:
self.robot_namespace = self._unique_names[concert_name];
except KeyError:
rospy.loginfo("App Manager: received invitation from %s, but haven't yet received a unique namespace to use"%concert_name)
if self._receive_invitation_callback(concert_address, concert_master.port, self.robot_namespace):
self.concert_master = concert_master
return True
else:
return False
class RPCHandler(Thread):
"""
Provides functions for RPCs.
"""
def __init__(self, config, logger, master, core):
Thread.__init__(self)
self.config = config
self.logger = logger
self.master = master
self.core = core
self.rpcserver = SimpleXMLRPCServer((self.config.rpcserver_host, self.config.rpcserver_port),
logRequests=False,
allow_none=True)
self.rpcserver.register_function(self.getStats, "getStats")
self.rpcserver.register_function(self.getContent, "getContent")
self.rpcserver.register_function(self.execAction, "execAction")
self.actions = {
"show_event": {'args': ['event'], 'function': self.execActionShowEvent},
"show_ruletable": {'args': [], 'function': self.execActionShowRuletable},
"show_querytable": {'args': [], 'function': self.execActionShowQuerytable},
"show_rulegroup": {'args': ['group'], 'function': self.execActionShowRulegroup},
"show_rule": {'args': ['group', 'rule'], 'function': self.execActionShowRule},
"show_context": {'args': ['group', 'name'], 'function': self.execActionShowContext},
"delete_context": {'args': ['group', 'name'], 'function': self.execActionDeleteContext},
"reload_rules": {'args': [], 'function': self.execActionReloadRules},
"clear_cache": {'args': [], 'function': self.execActionClearCache},
"show_inputqueue": {'args': [], 'function': self.execActionShowInputQueue},
"show_outputqueue": {'args': ["num"], 'function': self.execActionShowOutputQueue},
}
def getStats(self):
"""
Returns a list with statistics. Each item in the list is a tuple
representing a key/value pair.
"""
return [
("Current tick", self.master.ticker.getTick()),
("Time running", self.master.ticker.getTimeRunningString()),
("Processed input events", self.core.input_processed),
("Generated output events", self.core.output_generated),
("Events in input queue", self.master.input_queue.qsize()),
("Events in output queues", str([q.qsize() for q in self.master.output_queues])),
("Events in cache", len(self.core.cache.getEvents())),
("Current number of contexts", self.core.contextmanager.getNumberOfContexts()),
("Number of rules", self.core.rulemanager.getNumberOfRules()),
("Average event processing rate", "%3.2f events per minute" % (self.core.processingRate()*60))
]
def getContent(self, page):
"""
Returns the content of the given page.
@param page: string describing the page
"""
self.logger.logDebug("Returning RPC content for page '%s'." % page)
if page == 'home':
return [{
'title': "Welcome",
'type': "text",
'content': "This is ace running on %s." % self.config.hostname
}]
elif page == 'master':
return self.master.getContent()
elif page == 'core':
return self.core.getContent()
elif page == 'cache':
return self.core.cache.getContent()
elif page == 'contexts':
return self.core.contextmanager.getContent()
elif page == 'rulebase':
return self.core.rulemanager.getContent()
else:
return [{'title': "No such page exists", 'type': "text", 'content': page}]
def execAction(self, action, kwargs):
"""
Executes an RPC action and returns the content.
@param action: action
@type action: string
@param kwargs: arguments
@type kwargs: dict
"""
self.logger.logDebug("Executing RPC action '%s' with args %s." % (action, str(kwargs)))
if action in self.actions.keys():
needed_args = self.actions[action]['args']
for arg in needed_args:
if not kwargs.has_key(arg):
return [{
'title': "Error in execAction",
'type': "text",
'content': "Action '%s' needs argument '%s'." % (action, arg)
}]
kwargs = dict([kwarg for kwarg in kwargs.iteritems() if kwarg[0] in needed_args])
return self.actions[action]['function'](**kwargs)
else:
return [{
'title': "Error in execAction",
'type': "text",
'content': "No such action: %s" % action
}]
def execActionShowEvent(self, event):
"""
Returns content for an event.
"""
event = self.core.cache.getEventByID(event)
if event == None:
return [{
'title': "Error in execAction",
'type': "text",
'content': "No event with ID '%s' in cache." % event
}]
else:
return event.getContent() + [{
'title': "Relevant rules",
'type': 'list',
'content': [rule.getLink() for rule in self.core.rulemanager.getRelevantRules(event)]
}]
def execActionShowRuletable(self):
"""
Returns content for the rule table.
"""
def rulecontent(rules):
"""Helper function."""
if len(rules) < 1:
return ""
elif len(rules) == 1:
return rules[0].getLink()
else:
return reduce(lambda a, b: a+[", "]+b, [rule.getLink() for rule in rules])
table = self.core.rulemanager.ruletable
types = constants.EVENT_TYPES_ANY
return [{
'title': "Rules for events with any name and given type",
'type': 'table',
'headers': ["Type", "Rules"],
'content': [[etype, rulecontent([rule[2] for rule in sorted(table.when_any[etype])])]
for etype in types]
},{
'title': "Rules for events with given class and type",
'type': 'table',
'headers': ["Class", "Type", "Rules"],
'content': reduce(
lambda a, b: a + b,
[
[
[name, etype, rulecontent([rule[2]
for rule in sorted(table.when_class[name][etype])])]
for etype in types if len(table.when_class[name][etype]) > 0]
for name in table.when_class.keys()]
)
},{
'title': "Rules for events with given name and type",
'type': 'table',
'headers': ["Name", "Type", "Rules"],
'content': reduce(
lambda a,b: a+b,
[
[
[name, etype, rulecontent([rule[2]
for rule in sorted(table.when_event[name][etype])])]
for etype in types if len(table.when_event[name][etype]) > 0]
for name in table.when_event.keys()]
)
}]
def execActionShowQuerytable(self):
"""
Returns content for the query table.
"""
headers = ["Rule", "Query name", "Max age", "Time source", "Delay?"]
def limits_entry(entry, time_source, delay):
""" Returns a table row with delay/cache limits. """
return [entry['rule'].getLink() if entry['rule'] != None else "n/a",
entry['name'],
entry['max_age'],
time_source,
delay]
table = self.core.rulemanager.querytable
eventnames = set()
for delay in [True, False]:
for time_source in ['creation', 'arrival']:
eventnames.update(table[delay][time_source]['by_event'].keys())
eventnames = list(eventnames)
eventnames.sort()
content = [{
'title': "Default delay and cache times for any event",
'type': 'table',
'headers': headers,
'content': [limits_entry(table[delay][time_source]['any'], time_source, delay)
for time_source in ['creation', 'arrival'] for delay in [True, False]]
},{
'title': "Queries applicable to any event",
'type': 'table',
'headers': headers,
'content': [[qdet['rule'].getLink(), qdet['name'], qdet['max_age'], time_source, delay]
for delay in [True, False]
for time_source in ['creation', 'arrival']
for qdet in table[delay][time_source]['any']['qdets']]
}
]
for name in eventnames:
content.append({
'title': "Default delay and cache times for '%s'" % name,
'type': 'table',
'headers': headers,
'content': [limits_entry(table[delay][time_source]['by_event'][name], time_source, delay)
for delay in [True, False]
for time_source in ['creation', 'arrival']
if table[delay][time_source]['by_event'].has_key(name)]
})
content.append({
'title': "Queries for event '%s'" % name,
'type': 'table',
'headers': headers,
'content': [[qdet['rule'].getLink(), qdet['name'], qdet['max_age'], time_source, delay]
for delay in [True, False]
for time_source in ['creation', 'arrival']
if table[delay][time_source]['by_event'].has_key(name)
for qdet in table[delay][time_source]['by_event'][name]['qdets']
if table[delay][time_source]['by_event'][name].has_key('qdets')]
})
return content
def execActionShowRulegroup(self, group):
"""
Returns the content of a rule group.
"""
if self.core.rulemanager.hasGroup(group):
group = self.core.rulemanager.getGroup(group)
return group.getContent()
else:
return [{
'title': "No such group",
'type': "text",
'content': "RuleManager has no group '%s'." % group
}]
def execActionShowRule(self, group, rule):
"""
Returns the content for a single rule.
"""
if self.core.rulemanager.hasGroup(group):
group = self.core.rulemanager.getGroup(group)
if group.hasRule(rule):
rule = group.getRule(rule)
return rule.getContent()
else:
return [{
'title': "No such rule",
'type': "text",
'content': "Group '%s' has no rule '%s'." % (group, rule)
}]
else:
return [{
'title': "No such group",
'type': "text",
'content': "RuleManager has no group '%s'." % group
}]
def execActionShowContext(self, group, name):
"""
Returns the content of a context.
"""
if self.core.contextmanager.hasGroup(group):
group = self.core.contextmanager.getGroup(group)
if group.has_key(name):
context = group[name]
return context.getContent()
else:
return [{
'title': "No such context",
'type': "text",
'content': "Group '%s' has no context '%s'." % (group, name)
}]
else:
return [{
'title': "No such group",
'type': "text",
'content': "ContextManager has no group '%s'." % group
}]
def execActionDeleteContext(self, group, name):
"""
Asks the context manager to delete the specified context.
"""
if self.core.contextmanager.hasGroup(group):
contextgroup = self.core.contextmanager.getGroup(group)
if contextgroup.has_key(name):
self.core.contextmanager.triggerDeleteContext(group, name)
return [{
'title': "Context scheduled for deletion",
'type': "text",
'content': "Context '%s' in group '%s' will be deleted."\
% (name, group)
}]
else:
return [{
'title': "No such context",
'type': "text",
'content': "Group '%s' has no context '%s'." % (group, name)
}]
else:
return [{
'title': "No such group",
'type': "text",
'content': "ContextManager has no group '%s'." % group
}]
def execActionReloadRules(self):
"""
Asks the core to reload the rules.
"""
self.core.reloadRules()
return [{
'title': "Rule reload",
'type': "text",
'content': "Reload of correlation rules has been triggered."
}]
def execActionClearCache(self):
"""
Asks the core to delete all events from the cache.
"""
self.core.triggerClearCache()
return [{
'title': "Cache cleanup",
'type': "text",
'content': "Cleanup of event cache has been triggered."
}]
def execActionShowInputQueue(self):
"""
Returns the content for the events in the input queue.
"""
self.master.input_queue.mutex.acquire()
content = [{
'title': "Events in input queue:",
'type': 'table',
'headers': ["Name", "Type", "Status", "Host", "Description", "Arrival"],
'content': [[
e.getName(),
e.getType(),
e.getStatus(),
e.getHost(),
e.getDescription(),
e.getArrivalTime(),
] for e in sorted(self.master.input_queue.queue, key=lambda e:e.getArrivalTime())]
}]
self.master.input_queue.mutex.release()
return content
def execActionShowOutputQueue(self, num):
"""
Returns the content for the events in the output queue.
@param num: queue number
"""
if not num.isdigit():
return [{
'title': "Show output queue",
'type': "text",
'content': "No valid queue number: %s." % num
}]
qnum = int(num)
if not qnum < len(self.master.output_queues):
return [{
'title': "Show output queue",
'type': "text",
'content': "No such output queue: %d." % qnum
}]
self.master.output_queues[qnum].mutex.acquire()
content = [{
'title': "Events in output queue %d:" % qnum,
'type': 'table',
'headers': ["Name", "Type", "Status", "Host", "Description", "Arrival"],
'content': [[
e.getName(),
e.getType(),
e.getStatus(),
e.getHost(),
e.getDescription(),
e.getArrivalTime(),
] for e in sorted(self.master.output_queues[qnum].queue, key=lambda e:e.getArrivalTime())]
}]
self.master.output_queues[qnum].mutex.release()
return content
def run(self):
"""
Main thread function.
"""
self.logger.logInfo("Calling SimpleXMLRPCServer.serve_forever().")
try:
self.rpcserver.serve_forever()
except select.error as e:
self.logger.logErr("Calling of SimpleXMLRPCServer.serve_forever() failed: %s" % e)
def shutdown(self):
"""
Stops the server.
"""
self.logger.logInfo("Calling SimpleXMLRPCServer.shutdown().")
self.rpcserver.shutdown()
if success:
CURRENT_STATUS = STATUS_COMPLETED
else:
if error:
ERROR_MESSAGE = str(error)
CURRENT_STATUS = STATUS_FAILED
RESULTS_FOLDER = results
return True
if __name__ == "__main__":
try:
if not BIND_IP:
BIND_IP = socket.gethostbyname(socket.gethostname())
print("[+] Starting agent on %s:%s ..." % (BIND_IP, BIND_PORT))
# Disable DNS lookup, by Scott D.
def FakeGetFQDN(name=""):
return name
socket.getfqdn = FakeGetFQDN
server = SimpleXMLRPCServer((BIND_IP, BIND_PORT), allow_none=True)
server.register_instance(Agent())
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
class QarspDispatcher():
"""This class monitors the database, connects to devices, and dispatches orders to devices"""
def __init__(self):
self.dbconn = None
self.cursor = None
self.bonjour_thread = None
self.xmlrpc_thread = None
self.xmlrpc_server = None
self.device_list = []
self.device_addrs = []
self.orders_list = []
self.dispatched_orders = []
self.connectToDatabase()
def connectToDatabase(self):
"""Connects to the database"""
self.dbconn = pymysql.connect(host='127.0.0.1', port=8889, user='******', passwd='syse2011', db='qarsp_db')
self.cursor = self.dbconn.cursor()
def setupXMLRPC(self):
"""Starts the XMLRPC Server for communicating with the QARSP's"""
self.xmlrpc_server = SimpleXMLRPCServer(("", 8002), requestHandler=RequestHandler)
self.xmlrpc_server.register_function(self.register_qarsp, 'register')
self.xmlrpc_server.register_function(self.missionComplete_qarsp, 'missionComplete')
self.xmlrpc_server.register_function(self.updateMap_qarsp, 'updateMap')
self.xmlrpc_thread = threading.Thread(target=self.xmlrpc_server.serve_forever)
self.xmlrpc_thread.start()
def dnsregister_callback(self, sdRef, flags, errorCode, name, regtype, domain):
if errorCode == pybonjour.kDNSServiceErr_NoError:
print 'Registered service:'
print ' name =', name
print ' regtype =', regtype
print ' domain =', domain
def setupBonjour(self):
"""Registers the DNS service"""
name = "QarspService"
regtype = "_qarsp._tcp"
port = 1234
self.sdRef = \
pybonjour.DNSServiceRegister(name = name, regtype = regtype, port = port, callBack = self.dnsregister_callback)
self.bonjour_thread = threading.Thread(target=self.processBonjour)
self.bonjour_thread.start()
def shutdown(self):
"""Close open sockets"""
self.running = False
if(self.xmlrpc_server != None):
self.xmlrpc_server.shutdown()
if(self.cursor != None):
self.cursor.close()
if(self.dbconn != None):
self.dbconn.close()
if(self.bonjour_thread != None):
self.bonjour_thread.join(1)
if(self.xmlrpc_thread != None):
self.xmlrpc_thread.join(1)
self.sdRef.close()
def processBonjour(self):
"""Waits for devices to connect"""
while self.running:
ready = select.select([self.sdRef], [], [], 1)
if len(ready) != 0 and self.sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(self.sdRef)
def monitorDatabase(self):
"""Periodically checks the database for updated orders and device positions"""
self.running = True
self.setupXMLRPC()
self.setupBonjour()
while self.running:
# Grab the latest device and orders data
self.cursor.execute("SELECT * FROM device_loc")
self.device_list = []
for device in self.cursor:
device = Device(device)
self.device_list.append(device)
self.cursor.execute("SELECT * FROM orders_db")
self.orders_list = []
for order in self.cursor:
order = Order(order)
self.orders_list.append(order)
# Look for devices with assignments and non-zero locations
for device in self.device_list:
if device.lat != 0 and device.long != 0 and device.status_code > 0:
try:
order = self.orders_list[self.orders_list.index(device.status_code)]
except ValueError as error:
pass
try:
self.dispatched_orders.index(order.id)
except ValueError as error:
if order.lat != 0 and order.long != 0:
# Dispatch the order
self.dispatchOrder(order, device)
self.dispatched_orders.append(order)
time.sleep(1)
def register_qarsp(self, addr, port):
"""Allows a qarsp to register itself"""
self.device_addrs.append((addr, port))
query = "INSERT INTO device_loc (type, lat, lng, heading, status_code) VALUES (1, 32.606216, -85.486671, 0, -1)"
self.cursor.execute(query)
print "Device added with address: %s:%d" % (addr,port)
return True
def missionComplete_qarsp(self, qarsp_id):
"""Allows a qarsp to notify the dispatcher of a mission completion"""
return True
def updateMap_qarsp(self, mode, size, str_im):
"""docstring for updateMap_qarsp"""
from PIL import Image
import base64
str_im = base64.b64decode(str_im)
im = Image.fromstring(mode, size, str_im)
im.save("/Applications/MAMP/htdocs/map.jpeg", "JPEG")
return True
def dispatchOrder(self, order, device):
"""Dispatches an order to a given device"""
try:
s = xmlrpclib.ServerProxy('http://%s:%d' % self.device_addrs[self.device_list.index(device)])
# Convert Lat to Long
order_x, order_y = latlong2utm(order.lat, order.long)
device_x, device_y = latlong2utm(device.lat, device.long)
# s.dispatch(order_x-device_x, order_y-device_y)
s.dispatch(0, 5)
print "Dispatching device", device.id, "to", order.lat, order.long, "from", device.lat, device.long
except Exception as error:
print "Error dispatching qarsp:", str(error)
def shutdown(self):
SimpleXMLRPCServer.shutdown(self)
SimpleXMLRPCServer.server_close(self)
class GameServer:
def __init__(self, game):
self.__clients = []
self.__game = game
self.server_sock = None
self.server = None
# broadcast sender socket
self.sender_sock = socket(AF_INET, SOCK_DGRAM)
self.sender_sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
self.port = None
self.ip = None
def set_broadcast_port(self, port):
self.__game.set_broadcast_port(port)
def listen(self):
# Create XML server
if not self.port:
logging.error("Serving port was not specified")
return
self.server_sock = (DEFAULT_HOSTING_ADDR, self.port)
self.server = SimpleXMLRPCServer(self.server_sock,
requestHandler=MyServerRequestHandler)
LOG.debug('Server started listening RPC on %s:%s' % self.server_sock)
self.server.register_introspection_functions()
# Register all functions
# Register server-side functions into RPC middleware
self.server.register_instance(self.__game)
# self.server.register_function(function_name)
# def listen(self, sock_addr, backlog=1):
# self.__sock_addr = sock_addr
# self.__backlog = backlog
# self.__s = socket(AF_INET, SOCK_STREAM)
# self.__s.bind(self.__sock_addr)
# self.__s.listen(self.__backlog)
# LOG.debug('Socket %s:%d is in listening state' % self.__s.getsockname() )
def broadcast_ip_loop(self):
message = self.ip + MSG_FIELD_SEP + str(self.port)
logging.debug("Broadcasting to %s:%s server address %s:%s" %
(DEFAULT_BROADCAST_ADDR, DEFAULT_BROADCAST_IP_PORT,
self.ip, self.port))
while True:
self.sender_sock.sendto(
message, (DEFAULT_BROADCAST_ADDR, DEFAULT_BROADCAST_IP_PORT))
time.sleep(0.5)
def loop(self):
LOG.info('Falling to serving loop, press Ctrl+C to terminate...')
# clients = []
# client_socket = None
#
# try:
# while True:
# client_socket = None
# LOG.info('Awaiting new clients ...')
# client_socket, client_addr = self.__s.accept()
# c = PlayerSession(client_socket, client_addr, self.__game)
# clients.append(c)
# c.start()
# except KeyboardInterrupt:
# LOG.warn('Ctrl+C issued closing server ...')
# finally:
# if client_socket is not None:
# client_socket.close()
# self.__s.close()
# map(lambda x: x.join(), clients)
# Start broadcasting my IP for automatic discovery
broadcast_ip_thread = Thread(name='BroadcastIPThread',
target=self.broadcast_ip_loop)
broadcast_ip_thread.daemon = True # Make this thread close with the main thread
broadcast_ip_thread.start()
try:
self.server.serve_forever()
except KeyboardInterrupt:
print 'Ctrl+C issued, terminating ...'
finally:
self.server.shutdown() # Stop the serve-forever loop
self.server.server_close() # Close the sockets
print 'Terminating ...'
