def main():
host = sys.argv[1]
port = sys.argv[2]
server = SimpleXMLRPCServer((host, int(port)), allow_none=True)
server.register_introspection_functions()
server.register_instance(ChunkServer(host, port))
server.serve_forever()
class NetServer(Thread):
def __init__(self, port=8080, logRequests=True):
Thread.__init__(self)
self.__port = port
self.__logRequests = logRequests
self.__server = None
self.__running = False
self.State = None
self.start()
while not self.__running:
sleep(0)
def stop(self):
if self.State is not None:
self.State.set_update_period(0)
self.__server.shutdown()
self.__server.server_close()
self.join()
def run(self):
#register API
self.State = NetServerState(
) # accessor for state object for tests and shutting down, etc
self.__server = SimpleXMLRPCServer(("127.0.0.1", self.__port),
CrossDomainXMLRPCRequestHandler,
logRequests=self.__logRequests)
self.__server.register_instance(self.State)
self.__server.register_introspection_functions()
#start server
self.__running = True
self.__server.serve_forever()
class MasterServerProcess(multiprocessing.Process):
quit = False
def __init__(self, myIP, myPortNum, token, ready):
multiprocessing.Process.__init__(self)
#self.setDaemon(True)
self.daemon = True
self.server = SimpleXMLRPCServer((myIP, int(myPortNum)),
requestHandler=RequestHandler,
allow_none=True)
self.server.register_introspection_functions()
myFuncs = MyFuncs(token, ready)
self.funcs = myFuncs
self.server.register_instance(myFuncs)
def run(self):
# self.server.serve_forever()
while not self.quit:
self.server.handle_request()
def stop_server(self):
self.quit = True
self.server.server_close()
print("here")
return 0
def main():
process_name = 'interp_python'
killall(process_name) # kill previous instance if running
set_process_name(process_name)
tmp_dir = '/tmp/interp_python'
shutil.rmtree(tmp_dir, ignore_errors = True)
os.mkdir(tmp_dir)
# with open(os.path.join(tmp_dir, 'pid'), 'w') as f:
# f.write(str(os.getpid()) + '\n')
log_file = os.path.join(tmp_dir, 'log')
log_handler = logging.handlers.RotatingFileHandler(log_file,
backupCount = 1,
maxBytes = 4 * 1024 * 1024)
log_handler.setLevel(logging.INFO)
global log
log = logging.getLogger()
log.setLevel(logging.INFO)
log.addHandler(log_handler)
global common
common = import_module('interp_python_common.py')
global request_num
request_num = 0
global separator
separator = '-' * 80
# sys.exit()
# Create server:
server = SimpleXMLRPCServer(('localhost', 8000), requestHandler = RequestHandler)
server.register_introspection_functions()
server.register_function(execute)
server.serve_forever() # run the server's main loop
def xmlrpc_run(self, port=13100, bind='127.0.0.1', logRequests=False):
'''Run xmlrpc server'''
import umsgpack
try:
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.client import Binary
except ImportError:
from SimpleXMLRPCServer import SimpleXMLRPCServer
from xmlrpclib import Binary
logger.info("bloomfilter starting...")
server = SimpleXMLRPCServer((bind, port), allow_none=True, logRequests=logRequests)
server.register_introspection_functions()
server.register_multicall_functions()
server.register_function(self.quit, '_quit')
server.register_function(self.add, 'add')
server.timeout = 0.5
while not self._quit:
server.handle_request()
logger.info("bloomfilter exiting...")
server.server_close()
def main():
# Parse CLI options
import argparse
cli_parser = argparse.ArgumentParser(
description="XML-RPC server for filtering recommendations."
)
# Add verbosity option
cli_parser.add_argument('-v', '--verbose', action='store_true',
help='Be more verbose')
args = cli_parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.INFO)
filterServer = RecFilter()
server = SimpleXMLRPCServer(
(config.filter_server_hostname, config.filter_server_hostport),
allow_none=True)
server.register_introspection_functions()
server.register_function(filterServer.getRecs, 'getrecs')
print("Filter-server is running...")
# Run the server's main loop
server.serve_forever()
def main():
server = SimpleXMLRPCServer(('127.0.0.1', 7001))
server.register_introspection_functions()
server.register_multicall_functions()
server.register_function(send)
print("Server ready")
server.serve_forever()
class NetServer(Thread):
def __init__(self, port=8080, logRequests=True):
Thread.__init__(self)
self.__port = port
self.__logRequests = logRequests
self.__server = None
self.__running = False
self.State = None
self.start()
while not self.__running:
sleep(0)
def stop(self):
if self.State is not None:
self.State.set_update_period(0)
self.__server.shutdown()
self.__server.server_close()
self.join()
def run(self):
#register API
self.State = NetServerState() # accessor for state object for tests and shutting down, etc
self.__server = SimpleXMLRPCServer(("127.0.0.1", self.__port), CrossDomainXMLRPCRequestHandler, logRequests=self.__logRequests)
self.__server.register_instance(self.State)
self.__server.register_introspection_functions()
#start server
self.__running = True
self.__server.serve_forever()
def __init__(self, *args, **kwargs):
super(HeavyHitterDetect, self).__init__(*args, **kwargs)
# importing all functions from config file
self.config_obj = Config()
self.datapaths = {}
self.GLOBAL_THRESHOLD = self.config_obj.global_threshold
# this will run the polling method in a background thread
self.monitor_thread = hub.spawn(self._hhapp)
# running the XMLRPC in background
server = SimpleXMLRPCServer(('0.0.0.0', 9009),
logRequests=False,
allow_none=True)
server.register_introspection_functions()
server.register_multicall_functions()
# registering XMLRPC functions
server.register_instance(self)
server.register_function(self.updatestats, "updatestats")
server.register_function(self.config_obj.update_threshold_values,
"update_threshold")
server.register_function(self.config_obj.fetch_config_stats, "fetch")
self.key_stats = {}
self.mac_key_stats = {}
# xmlrpc commands that have to be run in a separate thread
# the spawn function creates a new thread
# normal threading does not work here
self.new_thread = hub.spawn(server.serve_forever)
def start_master(ip, port):
m = Master(f'http://{ip}:{port}', OP_LOG_FILENAME)
# restore previous launch's meta data
load_metadata(m)
# one time polling to get the list of chunks from each chunk server
m.chunk_manager.poll_chunkservers()
# call heartbeat
m.heartbeat()
master_server = SimpleXMLRPCServer((ip, port),
logRequests=True,
allow_none=True)
# Read: https://gist.github.com/abnvanand/199cacf6c8f45258ff096b842b77b216
master_server.register_introspection_functions()
# register all methods to be available to client
# can either use register_function(<function's_name>)
# or register_instance(<class's_instance>) # All the methods of the instance are published as XML-RPC methods
master_server.register_instance(m)
print("Master running at: ", m.my_addr)
master_server.serve_forever()
class RPCServerThread(threading.Thread):
def __init__(self,
methods_to_register,
rpc_port,
rpc_address="",
multithreaded=True):
threading.Thread.__init__(self)
self.daemon = False
self.stoprequest = threading.Event()
if multithreaded:
self.localServer = MultiThreadedXMLRPCServer(
(rpc_address, rpc_port),
LocalStackTraceHandler,
allow_none=True,
logRequests=False)
else:
self.localServer = SimpleXMLRPCServer((rpc_address, rpc_port),
LocalStackTraceHandler,
allow_none=True,
logRequests=False)
self.localServer.register_introspection_functions()
for method in methods_to_register:
self.localServer.register_function(method)
def run(self):
self.localServer.serve_forever()
def main():
addr = ('localhost', 8000)
server = SimpleXMLRPCServer(addr,
requestHandler=SimpleXMLRPCRequestHandler)
server.register_introspection_functions()
server.register_instance(ChatServer())
server.serve_forever()
class CallbackThread(threading.Thread):
"""Thread for XML-RPC callback server
To prevent SimpleXMLRPCServer blocking whole app it is started in a thread
"""
def __init__(self, port):
log("%s.%s port=%r", self.__class__.__name__, self.__init__.__name__, port)
super().__init__()
self.server = None
self.callback = ClientCallback()
self.port = port
self.current_test_case = None
def run(self):
"""Starts the xmlrpc callback server"""
log("%s.%s", self.__class__.__name__, self.run.__name__)
log("Serving on port %s ...", self.port)
self.server = SimpleXMLRPCServer(("", self.port),
allow_none=True, logRequests=False)
self.server.register_instance(self.callback)
self.server.register_introspection_functions()
self.server.serve_forever()
def stop(self):
thread = threading.Thread(target=self._shutdown_thread)
thread.start()
thread.join()
def _shutdown_thread(self):
self.server.shutdown()
def set_current_test_case(self, name):
log("%s.%s %s", self.__class__.__name__, self.set_current_test_case.__name__, name)
self.current_test_case = name
def get_current_test_case(self):
log("%s.%s %s", self.__class__.__name__, self.get_current_test_case.__name__, self.current_test_case)
return self.current_test_case
def error_code(self):
log("%s.%s", self.__class__.__name__, self.error_code.__name__)
return self.callback.error_code()
def set_pending_response(self, pending_response):
log("%s.%s, %r", self.__class__.__name__,
self.set_pending_response.__name__, pending_response)
return self.callback.set_pending_response(pending_response)
def clear_pending_responses(self):
log("%s.%s", self.__class__.__name__,
self.clear_pending_responses.__name__)
return self.callback.clear_pending_responses()
def cleanup(self):
log("%s.%s", self.__class__.__name__, self.cleanup.__name__)
return self.callback.cleanup()
def main():
server = SimpleXMLRPCServer(
(getenv("DFS_IP", "localhost"), int(getenv("DFS_PORT", "8000"))),
allow_none=True)
server.register_introspection_functions()
server.register_instance(Master())
server.serve_forever()
class BackendServer():
def __init__(self, address, functions_to_register):
#print(address)
#print(functions_to_register)
self.server = SimpleXMLRPCServer(address, logRequests=False)
self.register_functions(functions_to_register)
self.address = address
def register_functions(self, functions):
for f in functions:
self.server.register_function(f)
self.server.register_function(self.is_alive)
self.server.register_introspection_functions()
def is_alive(self, value):
return value
def serve_forever(self, blocking):
#print time.asctime(), "BackebdServer Starts - %s:%s " % self.address, "(blocking=%d)"%blocking
if blocking:
self.server.serve_forever()
else:
start_new_thread(self.server.serve_forever, ())
def stop(self):
pass
def main(args=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--address',
'-a',
default='0.0.0.0',
help='the '
'address on which the server is listening (e.g., '
'"127.0.0.1", default "0.0.0.0").')
parser.add_argument('--port',
'-p',
type=int,
default=9002,
help='the port'
' on which the server is listening (default "9002").')
args = parser.parse_args(args)
logging.basicConfig(format="%(asctime)s %(levelname)s "
"%(filename)s:%(lineno)d %(message)s")
LOG.setLevel(logging.INFO)
LOG.info("psutil version %s at %s", psutil.__version__, psutil.__file__)
server = SimpleXMLRPCServer((args.address, args.port))
LOG.info("serving on %s:%d", args.address, args.port)
server.register_introspection_functions()
server.register_instance(MonHelperRPCInterface())
server.serve_forever()
def start_server(obj):
"""
Purpose:
Start the XML-RPC server and register the "obj" class.
"""
try:
commandServer = SimpleXMLRPCServer(('', 9000), allow_none=True)
commandServer.register_introspection_functions()
commandServer.register_instance(obj)
print("{} - Starting to server forever".format(time.asctime()))
#Now keep the server alive till killed or system reboots
commandServer.serve_forever()
except KeyboardInterrupt as err:
print("{} - Keyboard Interrupt. Exiting.".format(time.asctime()))
return
except Exception as err:
print(err)
raise err
except System.Exception as err:
print(err)
raise err
def main():
# Create server
# commented block is for 3.7
# with SimpleXMLRPCServer(('localhost', 8000),
# requestHandler=RequestHandler) as server:
server = SimpleXMLRPCServer(
(HOST, PORT),
requestHandler=SingleClientRequestHandler,
allow_none=True,
)
server.register_introspection_functions()
controller = GoPiGoController()
server.register_instance(controller)
# Run the server's main loop
uprint('Serving XML-RPC on {host}:{port}'.format(host=HOST, port=PORT))
try:
server.serve_forever()
except KeyboardInterrupt:
uprint('\nKeyboard interrupt received, exiting.')
server.shutdown()
controller.cleanup()
sys.exit(0)
finally:
del controller
class SchedServer(object):
def __init__(self, ip="localhost", port=8000):
self.sched = scheduler.Scheduler()
self.server = SimpleXMLRPCServer((ip, port), requestHandler=RequestHandler)
self.server.register_introspection_functions()
self.serving = 0
self.server.register_function(self.push)
self.server.register_function(self.shutdown)
self.sched.run()
self.server.serve_forever()
def push(self, username, policy_number, code):
user_id = db_session.query(User.id).filter(User.username == username).one()[0]
db_task = Task(user_id, policy_number)
t = task.Task(program.Program(code), username, 3, 1000)
index = self.sched.add(t)
if index == -1:
print("Shutting down")
return -1
db_session.add(db_task)
db_session.commit()
ret_val = self.sched.get(index)
while ret_val is None:
ret_val = self.sched.get(index)
sleep(0.2)
return ret_val
def shutdown(self):
self.sched.join()
def run():
server = SimpleXMLRPCServer(("localhost", 22234),
requestHandler=RequestHandler,
logRequests=False)
server.register_introspection_functions()
server.register_function(translate, 'translate')
# Run the server's main loop
server.serve_forever()
def rpcserver():
server = SimpleXMLRPCServer(('localhost', 8000), requestHandler=TestRequestHandler)
server.register_introspection_functions()
server.register_function(pow)
server.register_function(adder_func, 'add')
server.register_instance(TestRPCClass())
server.serve_forever()
def get_server(host, port):
x = Server()
server = SimpleXMLRPCServer((host, port),
allow_none=True,
logRequests=False)
server.register_instance(x)
server.register_introspection_functions()
return (x, server)
class iCubTest:
""" iCub Test
tests XML-RPC with robot interface
"""
def __init__(self, robot):
self.robot = robot
self.robot.init_robot_pos().wait_for_completed()
self.logger = PykronLogger.getInstance()
self.M = iCubStateMachine()
self.yaw_threshold = 10
self.gp_threshold = 5
self.follow_threshold = 0.20 # follows for a between 0.0 and follow_threshold, max 1.0 for always
self.log("init finished")
# without allow_none the server will complain a lot about those functions not returning anything
self.server = SimpleXMLRPCServer(('localhost', 8081),
requestHandler=RequestHandler,
allow_none=True)
self.server.register_introspection_functions()
# maybe forward the whole instance of the class?
# TODO split it in half to allow that
self.server.register_function(self.turnLeft, "turnLeft")
self.server.register_function(self.turnRight, "turnRight")
self.server.register_function(self.start_trial, "start_trial")
self.server.register_function(self.end_trial, "end_trial")
def turnLeft(self):
self.log("leftStart")
self.M.follow_left(self.robot)
self.M.turnback_fromleft(self.robot)
self.log("leftEnd")
def turnRight(self):
self.log("rightStart")
self.M.follow_right(self.robot)
self.M.turnback_fromright(self.robot)
self.log("rightEnd")
def start_trial(self):
self.log('start trial')
self.M.start_trial(self.robot)
def end_trial(self):
self.log('end trial')
self.M.end_trial(self.robot)
def log(self, message):
# TODO add log type: error, debug
self.logger.log.debug(message)
def start(self):
self.log("server starting")
self.server.serve_forever()
self.log("server ending")
def main():
server_address = ('localhost', 10000)
server = SimpleXMLRPCServer(server_address)
xmlrpc_service = CalcService()
server.register_instance(xmlrpc_service)
server.register_introspection_functions()
print("CTRL-C to stop")
server.serve_forever()
def run(self):
server = SimpleXMLRPCServer((self.ip_address, self.port),
allow_none=True)
server.register_introspection_functions()
server.register_instance(self.controller)
print("Started server at %s:%s" % (self.ip_address, self.port))
server.serve_forever()
def main():
server = SimpleXMLRPCServer(('127.0.0.1', 7001))
server.register_introspection_functions()
server.register_multicall_functions()
server.register_function(addtogether)
server.register_function(quadratic)
server.register_function(remote_repr)
print("Server ready")
server.serve_forever()
def main():
server = SimpleXMLRPCServer(('127.0.0.1', 7001))
server.register_introspection_functions()
server.register_multicall_functions()
server.register_function(addtogether)
server.register_function(quadratic)
server.register_function(remote_repr)
print("Server ready")
server.serve_forever()
class ServerRPCMain:
def __init__(self, ip, puerto, tipo="main"):
self.server = SimpleXMLRPCServer((ip, puerto),
requestHandler=RequestHandler)
self.server.register_introspection_functions()
self.ip = ip
self.puerto = puerto
self.tipo = tipo
self.servers = {}
def menu(self):
return "---Operaciones---\n- suma - aplica valor1+valor2\n- resta - aplica valor1-valor2\n- multi - aplica valor1*valor2\n- div - aplica valor1/valor2\nDebe indicarse servidor, version, valor1, valor2, valor3, valor4\n la versión 1 es operación binarin, la 2 es de 3 valores y la 3 es de 4 valores"
def runServer(self):
print("corriendo server de tipo {}".format(self.tipo))
if self.tipo == "main":
print("conectado a servidores externos")
for i in ["suma", "resta", "multi", "div"]:
ipServer = str(
input("Ingrese la ip del server de {} -> ".format(i)))
puertoServer = str(
input("ingrese el puerto del server de {} -> ".format(i)))
print("server IP:", ipServer, i)
print("server port:", puertoServer, i)
self.servers[i] = xmlrpc.client.ServerProxy("http://" +
ipServer + ":" +
puertoServer)
print(
"Servidores conectados, iniciando servidor de comunicación media"
)
print("Server iniciado")
self.server.register_function(self.soliOP, 'op')
self.server.register_function(self.menu, 'menu')
self.server.serve_forever()
def soliOP(self, server, version, values):
print(
"Solicitando operación de los valores {} al servidor {}, versión {}"
.format(values, server, version))
if (server in [*self.servers]):
if (version + 1 == len(values) and len(values) > 1):
if (len(values) == 2):
value1, value2 = values
print("valores", value1, value2)
return self.servers[server].op1(value1, value2)
elif (len(values) == 3):
value1, value2, value3 = values
return self.servers[server].op2(value1, value2, value3)
elif (len(values) == 4):
value1, value2, value3, value4 = values
return self.servers[server].op3(value1, value2, value3,
value4)
return "Formato incorrecto"
else:
return "el servidor {} No existe".format(server)
class ServerAgent(InverseKinematicsAgent):
'''ServerAgent provides RPC service
'''
# YOUR CODE HERE
def __init__(self, ip_address='localhost', port=8888):
super().__init__()
self.__server = SimpleXMLRPCServer(addr=(ip_address, port),
allow_none=True)
self.__server.register_introspection_functions()
self.__server.register_function(self.get_angle)
self.__server.register_function(self.set_angle)
self.__server.register_function(self.get_posture)
self.__server.register_function(self.execute_keyframes)
self.__server.register_function(self.get_transform)
self.__server.register_function(self.set_transform)
Thread(target=self.__server.serve_forever).start()
def get_angle(self, joint_name):
'''get sensor value of given joint'''
# YOUR CODE HERE
return self.perception.joint[joint_name]
def set_angle(self, joint_name, angle):
'''set target angle of joint for PID controller
'''
# YOUR CODE HERE
self.target_joints[joint_name] = angle
def get_posture(self):
'''return current posture of robot'''
# YOUR CODE HERE
return self.posture
def execute_keyframes(self, key_frames):
'''excute keyframes, note this function is blocking call,
e.g. return until keyframes are executed
'''
# YOUR CODE HERE
self.keyframes = key_frames
while self.keyframes[0]:
sleep(0.2)
def get_transform(self, name):
'''get transform with given name
'''
# YOUR CODE HERE
return self.transforms[name]
def set_transform(self, effector_name, transform):
'''solve the inverse kinematics and control joints use the results
'''
# YOUR CODE HERE
self.set_transforms(effector_name, transform)
def main():
server = SimpleXMLRPCServer(('127.0.0.1', 7001))
server.register_introspection_functions()
server.register_multicall_functions()
server.register_function(firstPhase)
server.register_function(sendRand)
server.register_function(countKey)
server.register_function(secondPhase)
print("Server ready")
server.serve_forever()
def server_details():
server = SimpleXMLRPCServer(('127.0.0.1', 2346), requestHandler = MyXMLRPCServer, allow_none = True)
print("Server up and running on port 2346")
rpcgui.entry.insert(tk.END, "Server window "+ "\n")
server.register_introspection_functions()
server.register_function(connected_clients, "connected_clients")
server.register_function(receive_updates, "receive_updates")
server.register_function(consistent_files, "consistent_files")
server.serve_forever()
def main():
# Create server
server = SimpleXMLRPCServer(("localhost", 9004),
requestHandler=RequestHandler)
server.register_introspection_functions()
server.register_instance(RegisteredFunctions())
# Run the server's main loop
server.serve_forever()
class Server:
def __init__(self, name, port):
self.server = SimpleXMLRPCServer((name, port),
requestHandler=CARequestHandler)
self.server.register_introspection_functions()
self.server.register_instance(CentralAuthority(name))
def run(self):
# Run the server's main loop
self.server.serve_forever()
class RPCServer(threading.Thread):
"""
The RPCServer thread provides an API for external programs to interact
with MOM.
"""
def __init__(self, config, momFuncs):
threading.Thread.__init__(self, name="RPCServer")
self.setDaemon(True)
self.config = config
self.momFuncs = momFuncs
self.logger = logging.getLogger('mom.RPCServer')
self.server = None
self.start()
def thread_ok(self):
if self.server is None:
return True
return self.isAlive()
def create_server(self):
try:
unix_port = None
port = self.config.getint('main', 'rpc-port')
except ValueError:
port = None
unix_port = self.config.get('main', 'rpc-port')
self.logger.info("Using unix socket "+unix_port)
if unix_port is None and (port is None or port < 0):
return None
if unix_port:
self.server = UnixXmlRpcServer(unix_port)
else:
self.server = SimpleXMLRPCServer(("localhost", port),
requestHandler=RequestHandler, logRequests=0)
self.server.register_introspection_functions()
self.server.register_instance(self.momFuncs)
def shutdown(self):
if self.server is not None:
self.server.shutdown()
def run(self):
try:
self.create_server()
if self.server is not None:
self.logger.info("RPC Server starting")
self.server.serve_forever()
self.logger.info("RPC Server ending")
else:
self.logger.info("RPC Server is disabled")
except Exception as e:
self.logger.error("RPC Server crashed", exc_info=True)
def _start(self):
s = SimpleXMLRPCServer(("", self.port),
requestHandler=RequestHandler,
logRequests=False)
s.register_instance(self)
# h = s.get_request()
# x = h[1]
s.register_introspection_functions()
print("server start....")
self.server = s
s.serve_forever()
class ServerThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.localServer = SimpleXMLRPCServer((HOST, PORT),
requestHandler=RequestHandler,
allow_none=True)
self.localServer.register_introspection_functions()
self.localServer.register_instance(RemoteProcedures())
def run(self):
self.localServer.serve_forever()
def main():
logging.basicConfig(format="%(asctime)s %(levelname)s "
"%(filename)s:%(lineno)d %(message)s")
LOG.setLevel(logging.INFO)
LOG.info("psutil version %s at %s", psutil.__version__, psutil.__file__)
server = SimpleXMLRPCServer(("0.0.0.0", 9002))
server.register_introspection_functions()
server.register_instance(MonHelperRPCInterface())
server.serve_forever()
class RemoteController(metaclass=Singleton):
"""
Provide control over a SimpleXMLRPCServer.
"""
def __init__(self, ip='localhost', port=8070):
try:
self.server = SimpleXMLRPCServer((ip, port), allow_none=True,
logRequests=False)
self._announcer = Announcer()
except OSError as error:
# If address already in use
if error.errno == 98:
raise Exception(
"Only one application instance can use this module")
else:
raise error
self.server.register_introspection_functions()
self.server.register_instance(RemoteDispatcher())
@async
def start(self):
logging.info('REMOTE: Session started at ' +
str(self.server.server_address))
self._announcer.start()
self.server.serve_forever() # Blocking
self._announcer.stop()
logging.info('REMOTE: Session ended')
def stop(self):
self.server.shutdown()
@staticmethod
def connect_to(uri):
proxy = ServerProxy(uri, transport=TimeoutTransport())
try:
# Call a fictive method.
proxy._()
except Fault:
# Connected, the method doesn't exist, which is expected.
pass
except socket.error:
# Not connected, socket error mean that the service is unreachable.
raise OSError('Session at ' + uri + ' is unreachable')
# Just in case the method is registered in the XmlRPC server
return proxy
def main():
opt = parse_cmdline()
logging.basicConfig(format="%(asctime)s %(levelname)s "
"%(filename)s:%(lineno)d %(message)s")
LOG.setLevel(logging.INFO)
LOG.info("psutil version %s at %s", psutil.__version__, psutil.__file__)
server = SimpleXMLRPCServer((opt.ip, opt.port))
LOG.info("listening at %s:%s", opt.ip, opt.port)
server.register_introspection_functions()
server.register_instance(MonHelperRPCInterface())
server.serve_forever()
def start_xmlrpc(bindaddr):
from xmlrpc.server import (SimpleXMLRPCServer,
SimpleXMLRPCRequestHandler)
class handler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/motionwol',)
addr, port = bindaddr.split(':') #long live IPv4
server = SimpleXMLRPCServer((addr, int(port)), allow_none=True, requestHandler=handler)
server.register_introspection_functions()
server.register_function(disable_rules, 'disable')
server.register_function(enable_rules, 'enable')
XmlRpcDispatch(server.fileno()).server = server
def start_server(obj):
"""
Purpose:
Create the XML-RPC Server to allow CPython (and other tools) to interact with
the dksikuli instance and its Sikuli functions.
Similar to remotesrv.py's "start_server" function.
"""
guiServer = SimpleXMLRPCServer(('', 8080), allow_none=True)
guiServer.register_introspection_functions()
guiServer.register_instance(obj)
#Now keep the server alive till the end of the run
guiServer.serve_forever()
def startServer(box):
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2',)
# Create server
server = SimpleXMLRPCServer(("0.0.0.0", 8000),
requestHandler=RequestHandler, allow_none=True)
server.register_introspection_functions()
server.register_instance(box)
# Run the server's main loop
server.serve_forever()
def start_server(self):
"""
Purpose:
Start the XML-RPC server and register the "postrun" class.
"""
servicemanager.LogInfoMsg("Running in 'start_server'")
postrunObj = postrun()
commandServer = SimpleXMLRPCServer(("localhost", 9000), allow_none=True)
commandServer.register_introspection_functions()
commandServer.register_instance(postrunObj)
#Now keep the server alive till the end of the run
guiServer.serve_forever()
class RemoteController(Thread, metaclass=Singleton):
def __init__(self, ip='localhost', port=8070):
super().__init__(daemon=True)
self.setName('RemoteController')
self.server = SimpleXMLRPCServer((ip, port), allow_none=True,
logRequests=False)
self.server.register_introspection_functions()
self.server.register_instance(RemoteDispatcher())
self._announcer = Announcer()
def start(self):
self._announcer.start()
Thread.start(self)
def run(self):
logging.info('REMOTE: Session started at ' +
str(self.server.server_address))
self.server.serve_forever()
logging.info('REMOTE: Session ended')
def stop(self):
self.server.shutdown()
self._announcer.stop()
@staticmethod
def connect_to(uri):
proxy = ServerProxy(uri, transport=TimeoutTransport())
try:
# Call a fictive method.
proxy._()
except Fault:
# Connected, the method doesn't exist, which is expected.
pass
except socket.error:
# Not connected, socket error mean that the service is unreachable.
raise Exception('Session at ' + uri + ' is unreachable')
# Just in case the method is registered in the XmlRPC server
return proxy
def main():
parser = learn.get_argparser()
args = parser.parse_args()
brownclusters.set_paths_file(args.clusterfn)
triple_sentences = learn.load_bitext(args)
tl_sentences = learn.get_target_language_sentences(triple_sentences)
sl_sentences = [s for (s,t,a) in triple_sentences]
tagged_sentences = [list(zip(ss, ts))
for ss,ts in zip(sl_sentences, tl_sentences)]
learn.set_examples(sl_sentences,tagged_sentences)
# Create server
server = SimpleXMLRPCServer(("localhost", 8000),
requestHandler=RequestHandler)
server.register_introspection_functions()
server.register_function(label_sentence)
print("SERVER IS NOW ON IT.")
server.serve_forever()
def main(args=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--address', '-a', default='0.0.0.0', help='the '
'address on which the server is listening (e.g., '
'"127.0.0.1", default "0.0.0.0").')
parser.add_argument('--port', '-p', type=int, default=9002, help='the port'
' on which the server is listening (default "9002").')
args = parser.parse_args(args)
logging.basicConfig(format="%(asctime)s %(levelname)s "
"%(filename)s:%(lineno)d %(message)s")
LOG.setLevel(logging.INFO)
LOG.info("psutil version %s at %s", psutil.__version__, psutil.__file__)
server = SimpleXMLRPCServer((args.address, args.port))
LOG.info("serving on %s:%d", args.address, args.port)
server.register_introspection_functions()
server.register_instance(MonHelperRPCInterface())
server.serve_forever()
def start_driverdb_server(correct_protocol=True):
'''Create XML-RPC driver db server.
This will listen on localhost:8080 and serve fake_db. This must be
terminated with stop_driverdb_server().
If correct_protocol is False, this will answer with a bogus protocol
version.
'''
start_driverdb_server.pid = os.fork()
if start_driverdb_server.pid == 0:
try:
s = SimpleXMLRPCServer(('localhost', 8080), logRequests=False)
s.register_introspection_functions()
if correct_protocol:
s.register_function(xmlrpc_driverdb_query, 'query')
else:
s.register_function(xmlrpc_driverdb_query_bogus, 'query')
s.serve_forever()
except:
sys.stderr.write('********** DEMO XML-RPC server failed: ***********\n')
traceback.print_exc()
os._exit(1)
# wait until it is ready
c = ServerProxy('http://localhost:8080')
timeout = 100
while timeout > 0:
time.sleep(0.1)
try:
c.query('0', '0', {})
except socket.error:
timeout -= 1
continue
break
if timeout == 0:
raise SystemError('XML-RPC demo server did not start')
class RPCBot(ChatBot):
def __init__(self, *args, **kwargs):
super(RPCBot, self).__init__(*args, **kwargs)
self.lock = threading.RLock()
with self.lock:
self._pending_messages = []
self.start_rpc_server()
def run_pending(self):
with self.lock:
messages = copy.deepcopy(self._pending_messages)
self._pending_messages.clear()
for message in messages:
channel_id = self.broker.channel_id(message['channel'])
self.broker.post(
message['text'],
channel_id=channel_id,
)
def post(self, message):
with self.lock:
self._pending_messages.append(message)
def start_rpc_server(self):
def post_handler(channel, text):
self.post({
'channel': channel,
'text': text,
})
return True
self.server = SimpleXMLRPCServer(("localhost", 34278))
self.server.register_introspection_functions()
self.server.register_function(post_handler, 'post')
self.rpc_thread = threading.Thread(target=self.server.serve_forever)
self.rpc_thread.daemon = True
self.rpc_thread.start()
class RequestHandler(ThreadingMixIn, SimpleXMLRPCRequestHandler):
'''A (very) simple threaded XMLRPC server that accepts file
uploads from client instances.
'''
def __init__(self, ip, port, lock, logger, data_dir):
self.logger = logger
self.data_dir = data_dir
try:
self.server = SimpleXMLRPCServer((ip, port), logRequests=False)
except Exception as e:
self.logger.critical('The XMLRPC server won\'t start: %s', e)
sys.exit(1)
# A synchronization variable so we're not fighting with clients over files
# in the data directory
self.lock = lock
# This method gives us a way to check connectivity for clients
self.server.register_introspection_functions()
self.server.register_function(self.server_receive_file, 'server_receive_file')
if not os.path.exists(self.data_dir):
try:
os.makedirs(self.data_dir)
except OSError as e:
self.logger.critical('ERROR: XMLRPC server unable to create data directory: %s', e)
sys.exit(1)
try:
self.server.serve_forever()
except KeyboardInterrupt:
self.logger.info('XMLRPC server exiting normally in response to KILL signal')
sys.exit(0)
def server_receive_file(self, filename, contents):
self.logger.info('XMLRPC server received file from upstream client %s', filename.split('_')[0].replace('-', '.'))
self.lock.acquire()
with open(self.data_dir + '/' + filename, "wb") as handle:
handle.write(contents.data)
self.lock.release()
return True
if not type(message) is str: message = jsdumps(message)
subject, message = map(b64enc, (subject, message))
return bitmessage.sendMessage(toaddress, fromaddress, subject, message)
# Get a list of all new messages
from json import loads as jsloads
def receive():
messages = []
inbox = jsloads(bitmessage.getAllInboxMessages())['inboxMessages']
for msgid in (m['msgid'] for m in inbox):
message = jsloads(bitmessage.getInboxMessageByID(msgid))['inboxMessage'][0]
subject, message = map(b64dec, (message['subject'], message['message']))
messages.append({'subject': subject, 'message': message})
bitmessage.trashMessage(msgid)
return messages
# Serve RPC
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler
server = SimpleXMLRPCServer(("127.0.0.1", 6712), requestHandler=SimpleXMLRPCRequestHandler)
server.register_introspection_functions()
server.register_function(send, 'send')
server.register_function(receive, 'receive')
try:
server.serve_forever()
except KeyboardInterrupt:
from sys import exit
exit(0)
class XMLRPCServer(HardwareObject):
def __init__(self, name):
HardwareObject.__init__(self, name)
self.queue_model_hwobj = None
self.queue_hwobj = None
self.beamline_setup_hwobj = None
self.wokflow_in_progress = True
self.xmlrpc_prefixes = set()
self.current_entry_task = None
self.host = None
def init(self):
"""
Method inherited from HardwareObject, called by framework-2.
"""
# Listen on all interfaces if <all_interfaces>True</all_interfaces>
# otherwise only on the interface corresponding to socket.gethostname()
if hasattr(self, "all_interfaces") and self.all_interfaces:
host = ''
else:
host = socket.gethostname()
self.host = host
try:
self.open()
except:
logging.getLogger("HWR").debug("Can't start XML-RPC server")
def close(self):
try:
self.xmlrpc_server_task.kill()
self._server.server_close()
del self._server
except AttributeError:
pass
logging.getLogger("HWR").info('XML-RPC server closed')
def open(self):
# The value of the member self.port is set in the xml configuration
# file. The initialization is done by the baseclass HardwareObject.
if hasattr(self, "_server" ):
return
self.xmlrpc_prefixes = set()
self._server = SimpleXMLRPCServer((self.host, int(self.port)), logRequests = False, allow_none = True)
msg = 'XML-RPC server listening on: %s:%s' % (self.host, self.port)
logging.getLogger("HWR").info(msg)
self._server.register_introspection_functions()
self._server.register_function(self.start_queue)
self._server.register_function(self.log_message)
self._server.register_function(self.is_queue_executing)
self._server.register_function(self.queue_execute_entry_with_id)
self._server.register_function(self.shape_history_get_grid)
self._server.register_function(self.shape_history_set_grid_data)
self._server.register_function(self.beamline_setup_read)
self._server.register_function(self.get_diffractometer_positions)
self._server.register_function(self.move_diffractometer)
self._server.register_function(self.save_snapshot)
self._server.register_function(self.cryo_temperature)
self._server.register_function(self.flux)
self._server.register_function(self.set_aperture)
self._server.register_function(self.get_aperture)
self._server.register_function(self.get_aperture_list)
self._server.register_function(self.get_cp)
self._server.register_function(self.save_current_pos)
self._server.register_function(self.anneal)
# Register functions from modules specified in <apis> element
if self.hasObject("apis"):
apis = next(self.getObjects("apis"))
for api in apis.getObjects("api"):
recurse = api.getProperty("recurse")
if recurse is None:
recurse = True
self._register_module_functions(api.module, recurse=recurse)
self.queue_hwobj = self.getObjectByRole("queue")
self.queue_model_hwobj = self.getObjectByRole("queue_model")
self.beamline_setup_hwobj = self.getObjectByRole("beamline_setup")
self.shape_history_hwobj = self.beamline_setup_hwobj.shape_history_hwobj
self.diffractometer_hwobj = self.beamline_setup_hwobj.diffractometer_hwobj
self.xmlrpc_server_task = gevent.spawn(self._server.serve_forever)
def anneal(self, time):
cryoshutter_hwobj = self.getObjectByRole("cryoshutter")
try:
cryoshutter_hwobj.getCommandObject("anneal")(time)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return True
def _add_to_queue(self, task, set_on = True):
"""
Adds the TaskNode objects contained in the
list of TaskNodes passed in <task>.
The TaskNodes are marked as activated in the queue if <set_on>
is True and to inactivated if False.
:param task: TaskNode object to add to queue
:type parent: TaskNode
:param set_on: Mark TaskNode as activated if True and as inactivated
if false.
:type set_on: bool
:returns: True on success otherwise False
:rtype: bool
"""
# The exception is re raised so that it will
# be sent to the client.
try:
self.emit('add_to_queue', (task, None, set_on))
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return True
def start_queue(self):
"""
Starts the queue execution.
:returns: True on success otherwise False
:rtype: bool
"""
try:
self.emit('start_queue')
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return True
def log_message(self, message, level = 'info'):
"""
Logs a message in the user_level_log of MxCuBE,
normally displayed at the bottom of the MxCuBE
window.
:param message: The message to log
:type parent: str
:param message: The log level, one of the strings:
'info'. 'warning', 'error'
:type parent: str
:returns: True on success otherwise False
:rtype: bool
"""
status = True
if level == 'info':
logging.getLogger('user_level_log').info(message)
elif level == 'warning':
logging.getLogger('user_level_log').warning(message)
elif level == 'error':
logging.getLogger('user_level_log').error(message)
else:
status = False
return status
def _model_add_child(self, parent_id, child):
"""
Adds the model node task to parent_id.
:param parent_id: The id of the parent.
:type parent_id: int
:param child: The TaskNode object to add.
:type child: TaskNode
:returns: The id of the added TaskNode object.
:rtype: int
"""
try:
node_id = self.queue_model_hwobj.add_child_at_id(parent_id, child)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return node_id
def _model_get_node(self, node_id):
"""
:returns the TaskNode object with the node id <node_id>
:rtype: TaskNode
"""
try:
node = self.queue_model_hwobj.get_node(node_id)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return node
def queue_execute_entry_with_id(self, node_id):
"""
Execute the entry that has the model with node id <node_id>.
:param node_id: The node id of the model to find.
:type node_id: int
"""
try:
model = self.queue_model_hwobj.get_node(node_id)
entry = self.queue_hwobj.get_entry_with_model(model)
if entry:
self.current_entry_task = self.queue_hwobj.\
execute_entry(entry)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return True
def is_queue_executing(self, node_id=None):
"""
:returns: True if the queue is executing otherwise False
:rtype: bool
"""
try:
return self.queue_hwobj.is_executing(node_id)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
def queue_status(self):
pass
def shape_history_get_grid(self):
"""
:returns: The currently selected grid
:rtype: dict
Format of the returned dictionary:
{'id': id,
'dx_mm': float,
'dy_mm': float,
'steps_x': int,
'steps_y': int,
'x1': float,
'y1': float,
'angle': float}
"""
grid_dict = self.shape_history_hwobj.get_grid()
#self.shape_history_set_grid_data(grid_dict['id'], {})
return grid_dict
def shape_history_set_grid_data(self, key, result_data):
int_based_result = {}
for result in result_data.items():
int_based_result[int(result[0])] = result[1]
self.shape_history_hwobj.set_grid_data(key, int_based_result)
return True
def get_cp(self):
"""
:returns: a json encoded list with all centred positions
"""
cplist = []
points = self.shape_history_hwobj.get_points()
for point in points:
cp = point.get_centred_positions()[0].as_dict()
cplist.append(cp)
json_cplist = json.dumps(cplist)
return json_cplist
def beamline_setup_read(self, path):
try:
return self.beamline_setup_hwobj.read_value(path)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
def workflow_set_in_progress(self, state):
if state:
self.wokflow_in_progress = True
else:
self.wokflow_in_progress = False
def get_diffractometer_positions(self):
return self.diffractometer_hwobj.getPositions()
def move_diffractometer(self, roles_positions_dict):
self.diffractometer_hwobj.moveMotors(roles_positions_dict)
return True
def save_snapshot(self, imgpath):
self.diffractometer_hwobj.save_snapshot(imgpath)
return True
def save_current_pos(self):
"""
Saves the current position as a centered position.
"""
self.diffractometer_hwobj.saveCurrentPos()
return True
def cryo_temperature(self):
return self.beamline_setup_hwobj.collect_hwobj.get_cryo_temperature()
def flux(self):
flux = self.beamline_setup_hwobj.collect_hwobj.get_flux()
if flux is None:
flux = 0
return float(flux)
def set_aperture(self,pos_name, timeout=20):
self.diffractometer_hwobj.beam_info.aperture_hwobj.moveToPosition(pos_name)
t0=time.time()
while self.diffractometer_hwobj.beam_info.aperture_hwobj.getState() == 'MOVING':
time.sleep(0.1)
if time.time()-t0 > timeout:
raise RuntimeError("Timeout waiting for aperture to move")
return True
def get_aperture(self):
return self.diffractometer_hwobj.beam_info.aperture_hwobj.getPosition()
def get_aperture_list(self):
aperture_list=[]
for i in range(0, len(self.diffractometer_hwobj.beam_info.aperture_hwobj['positions'])):
aperture_list.append(self.diffractometer_hwobj.beam_info.aperture_hwobj['positions'][0][i].getProperty('name'))
return aperture_list
def _register_module_functions(self, module_name, recurse=True, prefix=""):
log = logging.getLogger("HWR")
log.info('Registering functions in module %s with XML-RPC server' %
module_name)
if module_name not in sys.modules:
__import__(module_name)
module = sys.modules[module_name]
if not hasattr(module, 'xmlrpc_prefix'):
log.error(('Module %s has no attribute "xmlrpc_prefix": cannot ' +
'register its functions. Skipping') % module_name)
else:
prefix += module.xmlrpc_prefix
if len(prefix) > 0 and prefix[-1] != '_':
prefix += '_'
if prefix in self.xmlrpc_prefixes:
msg = "Prefix %s already used: cannot register for module %s" % (prefix, module_name)
log.error(msg)
raise Exception(msg)
self.xmlrpc_prefixes.add(prefix)
for f in inspect.getmembers(module, inspect.isfunction):
if f[0][0] != '_':
xmlrpc_name = prefix + f[0]
log.info('Registering function %s.%s as XML-RPC function %s' %
(module_name, f[1].__name__, xmlrpc_name) )
# Bind method to this XMLRPCServer instance but don't set attribute
# This is sufficient to register it as an xmlrpc function.
bound_method = types.MethodType(f[1], self, self.__class__)
self._server.register_function(bound_method, xmlrpc_name)
# TODO: Still need to test with deeply-nested modules, in particular that
# modules and packages are both handled correctly in complex cases.
if recurse and hasattr(module, "__path__"):
sub_modules = pkgutil.walk_packages(module.__path__)
try:
sub_module = next(sub_modules)
self._register_module_functions( module_name + '.' + sub_module[1],
recurse=False, prefix=prefix)
except StopIteration:
pass
from xmlrpc.server import SimpleXMLRPCServer
class TestClass:
def __init__(self):
self.var = 1
def readme(self):
return self.var
srv = SimpleXMLRPCServer(("localhost", 2121))
srv.register_introspection_functions()
srv.register_instance(TestClass)
srv.serve_forever()
def start_rpc_server(self):
server = SimpleXMLRPCServer(('0.0.0.0', 9012), logRequests=True)
for f in self.get_rpc_functions():
server.register_function(f)
server.register_introspection_functions()
server.serve_forever()
class ServerThread(threading.Thread):
"""XML-RPC server thread to handle messages from CCU / Homegear"""
def __init__(self,
local=LOCAL,
localport=LOCALPORT,
remotes=REMOTES,
devicefile=DEVICEFILE,
interface_id=INTERFACE_ID,
eventcallback=False,
systemcallback=False,
resolveparamsets=False):
LOG.debug("ServerThread.__init__")
threading.Thread.__init__(self)
# Member
self._interface_id = interface_id
self._local = local
self._localport = int(localport)
self._devicefile = devicefile
self.remotes = remotes
self.eventcallback = eventcallback
self.systemcallback = systemcallback
self.resolveparamsets = resolveparamsets
self.proxies = {}
# Create proxies to interact with CCU / Homegear
LOG.debug("__init__: Creating proxies")
for remote, host in self.remotes.items():
try:
socket.inet_pton(socket.AF_INET, host['ip'])
except Exception as err:
LOG.warning("Skipping proxy: %s" % str(err))
continue
LOG.info("Creating proxy %s. Connecting to http://%s:%i" % (remote, host['ip'], host['port']))
try:
self.proxies["%s-%s" % (self._interface_id, remote)] = LockingServerProxy("http://%s:%i" % (host['ip'], host['port']))
except Exception as err:
LOG.warning("Failed connecting to proxy at http://%s:%i" % (host['ip'], host['port']))
LOG.debug("__init__: Exception: %s" % str(err))
raise Exception
if not self.proxies:
LOG.warning("No proxies available. Aborting.")
raise Exception
self._rpcfunctions = RPCFunctions(devicefile=self._devicefile,
proxies=self.proxies,
remotes=self.remotes,
eventcallback=self.eventcallback,
systemcallback=self.systemcallback,
resolveparamsets=self.resolveparamsets)
# Setup server to handle requests from CCU / Homegear
LOG.debug("ServerThread.__init__: Setting up server")
self.server = SimpleXMLRPCServer((self._local, self._localport),
requestHandler=RequestHandler,
logRequests=False)
self._localport = self.server.socket.getsockname()[1]
self.server.register_introspection_functions()
self.server.register_multicall_functions()
LOG.debug("ServerThread.__init__: Registering RPC functions")
self.server.register_instance(self._rpcfunctions, allow_dotted_names=True)
def run(self):
LOG.info("Starting server at http://%s:%i" % (self._local, self._localport))
self.server.serve_forever()
def proxyInit(self):
"""
To receive events the proxy has to tell the CCU / Homegear where to send the events. For that we call the init-method.
"""
# Call init() with local XML RPC config and interface_id (the name of the receiver) to receive events. XML RPC server has to be running.
for interface_id, proxy in self.proxies.items():
LOG.debug("ServerThread.proxyInit: init('http://%s:%i', '%s')" % (proxy._localip, self._localport, interface_id))
try:
proxy.init("http://%s:%i" % (proxy._localip, self._localport), interface_id)
LOG.info("Proxy initialized")
except Exception as err:
LOG.debug("proxyInit: Exception: %s" % str(err))
LOG.warning("Failed to initialize proxy")
raise Exception
def stop(self):
"""To stop the server we de-init from the CCU / Homegear, then shut down our XML-RPC server."""
stopped = []
for interface_id in self.proxies:
if not self.proxies[interface_id]._localip in stopped:
LOG.debug("ServerThread.stop: Deregistering proxy for server %s" % self.proxies[interface_id]._localip)
try:
self.proxies[interface_id].init("http://%s:%i" % (self.proxies[interface_id]._localip, self._localport))
stopped.append(self.proxies[interface_id]._localip)
except Exception as err:
LOG.warning("Failed to deregister proxy")
LOG.debug("stop: Exception: %s" % str(err))
del self.proxies[:]
LOG.info("Shutting down server")
self.server.shutdown()
LOG.debug("ServerThread.stop: Stopping ServerThread")
self.server.server_close()
LOG.info("Server stopped")
def parseCCUSysVar(self, data):
if data['type'] == 'LOGIC':
return data['name'], data['value'] == 'true'
elif data['type'] == 'NUMBER':
return data['name'], float(data['value'])
elif data['type'] == 'LIST':
return data['name'], int(data['value'])
else:
return data['name'], data['value']
def jsonRpcLogin(self, remote):
session = False
try:
params = {"username": self.remotes[remote]['username'], "password": self.remotes[remote]['password']}
response = self._rpcfunctions.jsonRpcPost(self.remotes[remote]['ip'], "Session.login", params)
if response['error'] is None and response['result']:
session = response['result']
if not session:
LOG.warning("ServerThread.jsonRpcLogin: Unable to open session.")
except Exception as err:
LOG.debug("ServerThread.jsonRpcLogin: Exception while logging in via JSON-RPC: %s" % str(err))
return session
def jsonRpcLogout(self, remote, session):
logout = False
try:
params = {"_session_id_": session}
response = self._rpcfunctions.jsonRpcPost(self.remotes[remote]['ip'], "Session.logout", params)
if response['error'] is None and response['result']:
logout = response['result']
except Exception as err:
LOG.debug("ServerThread.jsonRpcLogout: Exception while logging in via JSON-RPC: %s" % str(err))
return logout
def getAllSystemVariables(self, remote):
"""Get all system variables from CCU / Homegear"""
variables = {}
if self.remotes[remote]['username'] and self.remotes[remote]['password']:
LOG.debug("ServerThread.getAllSystemVariables: Getting all System variables via JSON-RPC")
session = self.jsonRpcLogin(remote)
if not session:
return
try:
params = {"_session_id_": session}
response = self._rpcfunctions.jsonRpcPost(self.remotes[remote]['ip'], "SysVar.getAll", params)
if response['error'] is None and response['result']:
for var in response['result']:
key, value = self.parseCCUSysVar(var)
variables[key] = value
self.jsonRpcLogout(remote, session)
except Exception as err:
self.jsonRpcLogout(remote, session)
LOG.warning("ServerThread.getAllSystemVariables: Exception: %s" % str(err))
else:
try:
variables = self.proxies["%s-%s" % (self._interface_id, remote)].getAllSystemVariables()
except Exception as err:
LOG.debug("ServerThread.getAllSystemVariables: Exception: %s" % str(err))
return variables
def getSystemVariable(self, remote, name):
"""Get single system variable from CCU / Homegear"""
var = None
if self.remotes[remote]['username'] and self.remotes[remote]['password']:
LOG.debug("ServerThread.getSystemVariable: Getting System variable via JSON-RPC")
session = self.jsonRpcLogin(remote)
if not session:
return
try:
params = {"_session_id_": session, "name": name}
response = self._rpcfunctions.jsonRpcPost(self.remotes[remote]['ip'], "SysVar.getValueByName", params)
if response['error'] is None and response['result']:
try:
var = float(response['result'])
except:
if response['result'] == 'true':
var = True
else:
var = False
self.jsonRpcLogout(remote, session)
except Exception as err:
self.jsonRpcLogout(remote, session)
LOG.warning("ServerThread.getSystemVariable: Exception: %s" % str(err))
else:
try:
var = self.proxies["%s-%s" % (self._interface_id, remote)].getSystemVariable(name)
except Exception as err:
LOG.debug("ServerThread.getSystemVariable: Exception: %s" % str(err))
return var
def deleteSystemVariable(self, remote, name):
"""Delete a system variable from CCU / Homegear"""
if self.remotes[remote]['username'] and self.remotes[remote]['password']:
LOG.debug("ServerThread.deleteSystemVariable: Getting System variable via JSON-RPC")
session = self.jsonRpcLogin(remote)
if not session:
return
try:
params = {"_session_id_": session, "name": name}
response = self._rpcfunctions.jsonRpcPost(self.remotes[remote]['ip'], "SysVar.deleteSysVarByName", params)
if response['error'] is None and response['result']:
deleted = response['result']
LOG.warning("ServerThread.deleteSystemVariable: Deleted: %s" % str(deleted))
self.jsonRpcLogout(remote, session)
except Exception as err:
self.jsonRpcLogout(remote, session)
LOG.warning("ServerThread.deleteSystemVariable: Exception: %s" % str(err))
else:
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].deleteSystemVariable(name)
except Exception as err:
LOG.debug("ServerThread.deleteSystemVariable: Exception: %s" % str(err))
def setSystemVariable(self, remote, name, value):
"""Set a system variable on CCU / Homegear"""
if self.remotes[remote]['username'] and self.remotes[remote]['password']:
LOG.debug("ServerThread.setSystemVariable: Setting System variable via JSON-RPC")
session = self.jsonRpcLogin(remote)
if not session:
return
try:
params = {"_session_id_": session, "name": name, "value": value}
if value is True or value is False:
response = self._rpcfunctions.jsonRpcPost(self.remotes[remote]['ip'], "SysVar.setBool", params)
else:
response = self._rpcfunctions.jsonRpcPost(self.remotes[remote]['ip'], "SysVar.setFloat", params)
if response['error'] is None and response['result']:
res = response['result']
LOG.debug("ServerThread.setSystemVariable: Result while setting variable: %s" % str(res))
else:
if response['error']:
LOG.debug("ServerThread.setSystemVariable: Error while setting variable: %s" % str(response['error']))
self.jsonRpcLogout(remote, session)
except Exception as err:
self.jsonRpcLogout(remote, session)
LOG.warning("ServerThread.setSystemVariable: Exception: %s" % str(err))
else:
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].setSystemVariable(name, value)
except Exception as err:
LOG.debug("ServerThread.setSystemVariable: Exception: %s" % str(err))
def getServiceMessages(self, remote):
"""Get service messages from CCU / Homegear"""
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].getServiceMessages()
except Exception as err:
LOG.debug("ServerThread.getServiceMessages: Exception: %s" % str(err))
def rssiInfo(self, remote):
"""Get RSSI information for all devices from CCU / Homegear"""
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].rssiInfo()
except Exception as err:
LOG.debug("ServerThread.rssiInfo: Exception: %s" % str(err))
def setInstallMode(self, remote, on=True, t=60, mode=1, address=None):
"""Activate or deactivate installmode on CCU / Homegear"""
try:
args = [on]
if on and t:
args.append(t)
if address:
args.append(address)
else:
args.append(mode)
return self.proxies["%s-%s" % (self._interface_id, remote)].setInstallMode(*args)
except Exception as err:
LOG.debug("ServerThread.setInstallMode: Exception: %s" % str(err))
def getInstallMode(self, remote):
"""Get remaining time in seconds install mode is active from CCU / Homegear"""
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].getInstallMode()
except Exception as err:
LOG.debug("ServerThread.getInstallMode: Exception: %s" % str(err))
def getAllMetadata(self, remote, address):
"""Get all metadata of device"""
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].getAllMetadata(address)
except Exception as err:
LOG.debug("ServerThread.getAllMetadata: Exception: %s" % str(err))
def getMetadata(self, remote, address, key):
"""Get metadata of device"""
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].getMetadata(address, key)
except Exception as err:
LOG.debug("ServerThread.getMetadata: Exception: %s" % str(err))
def setMetadata(self, remote, address, key, value):
"""Set metadata of device"""
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].setMetadata(address, key, value)
except Exception as err:
LOG.debug("ServerThread.setMetadata: Exception: %s" % str(err))
def deleteMetadata(self, remote, address, key):
"""Delete metadata of device"""
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].deleteMetadata(address, key)
except Exception as err:
LOG.debug("ServerThread.deleteMetadata: Exception: %s" % str(err))
def listBidcosInterfaces(self, remote):
"""Return all available BidCos Interfaces"""
try:
return self.proxies["%s-%s" % (self._interface_id, remote)].listBidcosInterfaces()
except Exception as err:
LOG.debug("ServerThread.listBidcosInterfaces: Exception: %s" % str(err))
#coding=utf-8
'''
Created on 2013-6-3
@author: zhaojp
'''
from xmlrpc.server import SimpleXMLRPCServer;
import math;
def add(x, y):
"Adds two numbers"
return x + y;
s = SimpleXMLRPCServer(('', 8080));
s.register_function(add);
s.register_instance(math);
s.register_introspection_functions();
s.serve_forever();
class XMLRPCServer(HardwareObject):
def __init__(self, name):
HardwareObject.__init__(self, name)
self.host = None
self.port = None
self.all_interfaces = None
self.enforceUseOfToken = None
self.queue_model_hwobj = None
self.queue_hwobj = None
self.beamline_setup_hwobj = None
self.wokflow_in_progress = True
self.xmlrpc_prefixes = set()
self.current_entry_task = None
self.host = None
self.doEnforceUseOfToken = False
atexit.register(self.close)
def init(self):
"""
Method inherited from HardwareObject, called by framework-2.
"""
self.all_interfaces = self.getProperty('all_interfaces')
# Listen on all interfaces if <all_interfaces>True</all_interfaces>
# otherwise only on the interface corresponding to socket.gethostname()
if self.all_interfaces:
host = ''
else:
host = socket.gethostname()
self.host = host
self.port = self.getProperty('port')
# Check if communication should be "secure". If self.doEnforceUseOfToken is set to True
# all incoming http requests must have the correct token in the headers.
self.enforceUseOfToken = self.getProperty('enforceUseOfToken')
if self.enforceUseOfToken:
self.doEnforceUseOfToken = True
#try:
self.open()
#except:
# logging.getLogger("HWR").debug("Can't start XML-RPC server")
def close(self):
try:
self.xmlrpc_server_task.kill()
self._server.server_close()
del self._server
except AttributeError:
pass
logging.getLogger("HWR").info('XML-RPC server closed')
def open(self):
# The value of the member self.port is set in the xml configuration
# file. The initialization is done by the baseclass HardwareObject.
if hasattr(self, "_server" ):
return
self.xmlrpc_prefixes = set()
if self.doEnforceUseOfToken:
self._server = SimpleXMLRPCServer((self.host, int(self.port)), requestHandler=SecureXMLRpcRequestHandler,
logRequests = False, allow_none = True)
else:
self._server = SimpleXMLRPCServer((self.host, int(self.port)), logRequests = False, allow_none = True)
msg = 'XML-RPC server listening on: %s:%s' % (self.host, self.port)
logging.getLogger("HWR").info(msg)
self._server.register_introspection_functions()
self._server.register_function(self.start_queue)
self._server.register_function(self.log_message)
self._server.register_function(self.is_queue_executing)
self._server.register_function(self.queue_execute_entry_with_id)
self._server.register_function(self.shape_history_get_grid)
self._server.register_function(self.shape_history_set_grid_data)
self._server.register_function(self.beamline_setup_read)
self._server.register_function(self.get_diffractometer_positions)
self._server.register_function(self.move_diffractometer)
self._server.register_function(self.save_snapshot)
self._server.register_function(self.cryo_temperature)
self._server.register_function(self.flux)
self._server.register_function(self.set_aperture)
self._server.register_function(self.get_aperture)
self._server.register_function(self.get_aperture_list)
self._server.register_function(self.get_cp)
self._server.register_function(self.save_current_pos)
self._server.register_function(self.anneal)
self._server.register_function(self.open_dialog)
self._server.register_function(self.workflow_end)
self._server.register_function(self.dozor_batch_processed)
self._server.register_function(self.dozor_status_changed)
self._server.register_function(self.add_processing_message)
self.image_num = 0
self._server.register_function(self.get_image_num, "get_image_num")
self._server.register_function(self.set_zoom_level)
self._server.register_function(self.get_zoom_level)
self._server.register_function(self.get_available_zoom_levels)
self._server.register_function(self.set_front_light_level)
self._server.register_function(self.get_front_light_level)
self._server.register_function(self.set_back_light_level)
self._server.register_function(self.get_back_light_level)
self._server.register_function(self.centre_beam)
# Register functions from modules specified in <apis> element
if self.hasObject("apis"):
apis = next(self.getObjects("apis"))
for api in apis.getObjects("api"):
recurse = api.getProperty("recurse")
if recurse is None:
recurse = True
self._register_module_functions(api.getProperty('module'), recurse=recurse)
self.queue_hwobj = self.getObjectByRole("queue")
self.queue_model_hwobj = self.getObjectByRole("queue_model")
self.beamline_setup_hwobj = self.getObjectByRole("beamline_setup")
self.shape_history_hwobj = self.beamline_setup_hwobj.shape_history_hwobj
self.diffractometer_hwobj = self.beamline_setup_hwobj.diffractometer_hwobj
self.collect_hwobj = self.beamline_setup_hwobj.collect_hwobj
#self.connect(self.collect_hwobj,
# 'collectImageTaken',
# self.image_taken)
self.xmlrpc_server_task = gevent.spawn(self._server.serve_forever)
self.workflow_hwobj = self.getObjectByRole("workflow")
self.beamcmds_hwobj = self.getObjectByRole("beamcmds")
def anneal(self, time):
cryoshutter_hwobj = self.getObjectByRole("cryoshutter")
try:
cryoshutter_hwobj.getCommandObject("anneal")(time)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return True
def _add_to_queue(self, task, set_on = True):
"""
Adds the TaskNode objects contained in the
list of TaskNodes passed in <task>.
The TaskNodes are marked as activated in the queue if <set_on>
is True and to inactivated if False.
:param task: TaskNode object to add to queue
:type parent: TaskNode
:param set_on: Mark TaskNode as activated if True and as inactivated
if false.
:type set_on: bool
:returns: True on success otherwise False
:rtype: bool
"""
# The exception is re raised so that it will
# be sent to the client.
try:
self.emit('add_to_queue', (task, None, set_on))
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return True
def start_queue(self):
"""
Starts the queue execution.
:returns: True on success otherwise False
:rtype: bool
"""
try:
self.emit('start_queue')
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return True
def log_message(self, message, level = 'info'):
"""
Logs a message in the user_level_log of MxCuBE,
normally displayed at the bottom of the MxCuBE
window.
:param message: The message to log
:type parent: str
:param message: The log level, one of the strings:
'info'. 'warning', 'error'
:type parent: str
:returns: True on success otherwise False
:rtype: bool
"""
status = True
if level == 'info':
logging.getLogger('user_level_log').info(message)
elif level == 'warning':
logging.getLogger('user_level_log').warning(message)
elif level == 'error':
logging.getLogger('user_level_log').error(message)
else:
status = False
return status
def _model_add_child(self, parent_id, child):
"""
Adds the model node task to parent_id.
:param parent_id: The id of the parent.
:type parent_id: int
:param child: The TaskNode object to add.
:type child: TaskNode
:returns: The id of the added TaskNode object.
:rtype: int
"""
try:
node_id = self.queue_model_hwobj.add_child_at_id(parent_id, child)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return node_id
def _model_get_node(self, node_id):
"""
:returns the TaskNode object with the node id <node_id>
:rtype: TaskNode
"""
try:
node = self.queue_model_hwobj.get_node(node_id)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return node
def queue_execute_entry_with_id(self, node_id):
"""
Execute the entry that has the model with node id <node_id>.
:param node_id: The node id of the model to find.
:type node_id: int
"""
try:
model = self.queue_model_hwobj.get_node(node_id)
entry = self.queue_hwobj.get_entry_with_model(model)
if entry:
self.current_entry_task = self.queue_hwobj.\
execute_entry(entry)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
else:
return True
def is_queue_executing(self, node_id=None):
"""
:returns: True if the queue is executing otherwise False
:rtype: bool
"""
try:
return self.queue_hwobj.is_executing(node_id)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
def queue_status(self):
pass
def shape_history_get_grid(self):
"""
:returns: The currently selected grid
:rtype: dict
Format of the returned dictionary:
{'id': id,
'dx_mm': float,
'dy_mm': float,
'steps_x': int,
'steps_y': int,
'x1': float,
'y1': float,
'angle': float}
"""
grid_dict = self.shape_history_hwobj.get_grid()
#self.shape_history_set_grid_data(grid_dict['id'], {})
return grid_dict
def shape_history_set_grid_data(self, key, result_data):
int_based_result = {}
for result in result_data.iteritems():
int_based_result[int(result[0])] = result[1]
self.shape_history_hwobj.set_grid_data(key, int_based_result)
return True
def get_cp(self):
"""
:returns: a json encoded list with all centred positions
"""
cplist = []
points = self.shape_history_hwobj.get_points()
for point in points:
cp = point.get_centred_positions()[0].as_dict()
cplist.append(cp)
json_cplist = json.dumps(cplist)
return json_cplist
def beamline_setup_read(self, path):
try:
return self.beamline_setup_hwobj.read_value(path)
except Exception as ex:
logging.getLogger('HWR').exception(str(ex))
raise
def workflow_set_in_progress(self, state):
if state:
self.wokflow_in_progress = True
else:
self.wokflow_in_progress = False
def get_diffractometer_positions(self):
return self.diffractometer_hwobj.getPositions()
def move_diffractometer(self, roles_positions_dict):
self.diffractometer_hwobj.moveMotors(roles_positions_dict)
return True
def save_snapshot(self, imgpath, showScale=True):
res = True
try:
if showScale:
self.diffractometer_hwobj.save_snapshot(imgpath)
else:
self.diffractometer_hwobj.getObjectByRole("camera").takeSnapshot(imgpath)
except Exception as ex:
logging.getLogger('HWR').exception("Could not take snapshot %s " % str(ex))
res = False
return res
def save_current_pos(self):
"""
Saves the current position as a centered position.
"""
self.diffractometer_hwobj.saveCurrentPos()
return True
def cryo_temperature(self):
return self.beamline_setup_hwobj.collect_hwobj.get_cryo_temperature()
def flux(self):
flux = self.beamline_setup_hwobj.collect_hwobj.get_flux()
if flux is None:
flux = 0
return float(flux)
def set_aperture(self,pos_name, timeout=20):
self.diffractometer_hwobj.beam_info.aperture_hwobj.moveToPosition(pos_name)
t0=time.time()
while self.diffractometer_hwobj.beam_info.aperture_hwobj.getState() == 'MOVING':
time.sleep(0.1)
if time.time()-t0 > timeout:
raise RuntimeError("Timeout waiting for aperture to move")
return True
def get_aperture(self):
return self.diffractometer_hwobj.beam_info.aperture_hwobj.getCurrentPositionName()
def get_aperture_list(self):
return self.diffractometer_hwobj.beam_info.aperture_hwobj.getPredefinedPositionsList()
def open_dialog(self, dict_dialog):
"""
Opens the workflow dialog in mxCuBE.
This call blocks util the dialog is ended by the user.
"""
return_map = {}
if self.workflow_hwobj is not None:
return_map = self.workflow_hwobj.open_dialog(dict_dialog)
self.emit("open_dialog", dict_dialog)
return return_map
def workflow_end(self):
"""
Notify the workflow HO that the workflow has finished.
"""
if self.workflow_hwobj is not None:
self.workflow_hwobj.workflow_end()
def dozor_batch_processed(self, dozor_batch_dict):
self.beamline_setup_hwobj.parallel_processing_hwobj.batch_processed(dozor_batch_dict)
def dozor_status_changed(self, status):
self.beamline_setup_hwobj.parallel_processing_hwobj.\
set_processing_status(status)
def add_processing_message(self, collection_id, msg):
for queue_entry in self.queue_model_hwobj.get_all_dc_queue_entries():
if queue_entry.get_data_model().id == collection_id:
queue_entry.get_data_model().processing_msg_list.append(\
"%s: %s" % (str(time.strftime("%Y-%m-%d %H:%M:%S")), msg))
def image_taken(self, image_num):
self.image_num = image_num
def get_image_num(self):
return self.image_num
def set_zoom_level(self, zoom_level):
"""
Sets the zoom to a pre-defined level.
"""
self.diffractometer_hwobj.zoomMotor.moveToPosition(zoom_level)
def get_zoom_level(self):
"""
Returns the zoom level.
"""
return self.diffractometer_hwobj.zoomMotor.getCurrentPositionName()
def get_available_zoom_levels(self):
"""
Returns the avaliable pre-defined zoom levels.
"""
return self.diffractometer_hwobj.zoomMotor.getPredefinedPositionsList()
def set_front_light_level(self, level):
"""
Sets the level of the front light
"""
self.diffractometer_hwobj.setFrontLightLevel(level)
def get_front_light_level(self):
"""
Gets the level of the front light
"""
return self.diffractometer_hwobj.getFrontLightLevel()
def set_back_light_level(self, level):
"""
Sets the level of the back light
"""
self.diffractometer_hwobj.setBackLightLevel(level)
def get_back_light_level(self):
"""
Gets the level of the back light
"""
return self.diffractometer_hwobj.getBackLightLevel()
def centre_beam(self):
"""
Centers the beam using the beamcmds hardware object.
"""
self.beamcmds_hwobj.centrebeam()
while self.beamcmds_hwobj.centrebeam._cmd_execution and not self.beamcmds_hwobj.centrebeam._cmd_execution.ready():
time.sleep(1)
def _register_module_functions(self, module_name, recurse=True, prefix=""):
log = logging.getLogger("HWR")
log.info('Registering functions in module %s with XML-RPC server' %
module_name)
if not sys.modules.has_key(module_name):
__import__(module_name)
module = sys.modules[module_name]
if not hasattr(module, 'xmlrpc_prefix'):
log.error(('Module %s has no attribute "xmlrpc_prefix": cannot ' +
'register its functions. Skipping') % module_name)
else:
prefix += module.xmlrpc_prefix
if len(prefix) > 0 and prefix[-1] != '_':
prefix += '_'
if prefix in self.xmlrpc_prefixes:
msg = "Prefix %s already used: cannot register for module %s" % (prefix, module_name)
log.error(msg)
raise Exception(msg)
self.xmlrpc_prefixes.add(prefix)
for f in inspect.getmembers(module, inspect.isfunction):
if f[0][0] != '_':
xmlrpc_name = prefix + f[0]
log.info('Registering function %s.%s as XML-RPC function %s' %
(module_name, f[1].__name__, xmlrpc_name) )
# Bind method to this XMLRPCServer instance but don't set attribute
# This is sufficient to register it as an xmlrpc function.
bound_method = types.MethodType(f[1], self, self.__class__)
self._server.register_function(bound_method, xmlrpc_name)
# TODO: Still need to test with deeply-nested modules, in particular that
# modules and packages are both handled correctly in complex cases.
if recurse and hasattr(module, "__path__"):
sub_modules = pkgutil.walk_packages(module.__path__)
try:
sub_module = next(sub_modules)
self._register_module_functions( module_name + '.' + sub_module[1],
recurse=False, prefix=prefix)
except StopIteration:
pass
def setToken(self, token):
SecureXMLRpcRequestHandler.setReferenceToken(token)
class ServerThread(threading.Thread):
"""XML-RPC server thread to handle messages from CCU / Homegear"""
def __init__( self,
local = LOCAL,
localport = LOCALPORT,
remote = REMOTE,
remoteport = REMOTEPORT,
devicefile = DEVICEFILE,
interface_id = INTERFACE_ID,
eventcallback = False,
systemcallback = False):
global LOCAL, LOCALPORT, REMOTE, REMOTEPORT, DEVICEFILE, INTERFACE_ID
LOG.debug("ServerThread.__init__")
threading.Thread.__init__(self)
INTERFACE_ID = interface_id
LOCAL = local
LOCALPORT = localport
REMOTE = remote
REMOTEPORT = remoteport
DEVICEFILE = devicefile
self.eventcallback = eventcallback
self.systemcallback = systemcallback
self.proxy = False
# Setup server to handle requests from CCU / Homegear
LOG.debug("ServerThread.__init__: Setting up server")
self.server = SimpleXMLRPCServer( (LOCAL, int(LOCALPORT)),
requestHandler=RequestHandler )
self.server.register_introspection_functions()
self.server.register_multicall_functions()
LOG.debug("ServerThread.__init__: Registering RPC functions")
self.server.register_instance(RPCFunctions(devicefile = DEVICEFILE, proxy = self.proxy, eventcallback = self.eventcallback, systemcallback = self.systemcallback))
def run(self):
LOG.info("Starting server at http://%s:%i" % (LOCAL, int(LOCALPORT)))
self.server.serve_forever()
def connect(self):
# Create proxy to interact with CCU / Homegear
LOG.info("Creating proxy. Connecting to http://%s:%i" % (REMOTE, int(REMOTEPORT)))
try:
self.proxy = xmlrpc.client.ServerProxy("http://%s:%i" % (REMOTE, int(REMOTEPORT)))
except:
LOG.warning("Failed connecting to proxy at http://%s:%i" % (REMOTE, int(REMOTEPORT)))
raise Exception
def proxyInit(self):
"""To receive events the proxy has to tell the CCU / Homegear where to send the events. For that we call the init-method."""
# Call init() with local XML RPC config and interface_id (the name of the receiver) to receive events. XML RPC server has to be running.
LOG.debug("ServerThread.proxyInit: init(http://%s:%i, '%s')" % (LOCAL, int(LOCALPORT), INTERFACE_ID) )
try:
self.proxy.init("http://%s:%i" % (LOCAL, int(LOCALPORT)), INTERFACE_ID)
LOG.info("Proxy initialized")
except:
LOG.warning("Failed to initialize proxy")
raise Exception
def stop(self):
"""To stop the server we de-init from the CCU / Homegear, then shut down our XML-RPC server."""
if self.proxy:
LOG.debug("ServerThread.stop: Deregistering proxy")
try:
self.proxy.init("http://%s:%i" % (LOCAL, int(LOCALPORT)))
except:
LOG.warning("Failed to deregister proxy")
LOG.info("Shutting down server")
self.server.shutdown()
LOG.debug("ServerThread.stop: Stopping ServerThread")
self.server.server_close()
LOG.info("Server stopped")
