class MyXMLRPCServer(Thread):
def __init__(self, nodeAddrHostPort):
Thread.__init__(self)
self.setDaemon(True)
self.quit = False
self.nodeAddrHostPort = nodeAddrHostPort
self.server = SimpleXMLRPCServer( nodeAddrHostPort )
print("Listening on port %d ..." % nodeAddrHostPort[1])
self.server.register_function(publisherUpdate, "publisherUpdate")
self.server.register_function(requestTopic, "requestTopic")
self.server.register_function(self.request_shutdown, 'request_shutdown')
self.start()
def request_shutdown(self):
self.quit = True
return True
def run(self):
while not self.quit:
self.server.handle_request()
def shutdown(self):
url = "http://{}:{}".format(*self.nodeAddrHostPort)
s = ServerProxy(url)
s.request_shutdown()
self.join(timeout=1)
if self.is_alive():
raise RuntimeError("MyXMLRPCServer failed to shutdown.")
self.server.server_close()
class DummyROSMaster(Thread):
def __init__(self, host_port_addr):
Thread.__init__(self)
self.setDaemon(True)
self.server = SimpleXMLRPCServer(host_port_addr)
print('Listening on %s:%d ...' % host_port_addr)
self.server.register_function(getSystemState, 'getSystemState')
self.server.register_function(registerPublisher, 'registerPublisher')
self.server.register_function(registerSubscriber, 'registerSubscriber')
# fake calls for "real" ROS node
self.server.register_function(requestTopic, 'requestTopic')
self.server.register_function(self.request_shutdown,
'request_shutdown')
self.quit = False
self.host_port_addr = host_port_addr
self.start()
def request_shutdown(self):
self.quit = True
return True
def run(self):
while not self.quit:
self.server.handle_request()
def shutdown(self):
url = "http://{}:{}".format(*self.host_port_addr)
s = ServerProxy(url)
s.request_shutdown()
self.join(timeout=1)
if self.is_alive():
raise RuntimeError("DummyROSMaster failed to shutdown.")
self.server.server_close()
def _watch_posts(self):
host = ask_user('My IP:')
port = int(ask_user('My port:'))
def notify_new_post(post):
print(format_posts([post]))
print()
try:
rpc_server = SimpleXMLRPCServer((host, port),
logRequests=False,
allow_none=True)
rpc_server.register_function(notify_new_post)
self._server.register_listener(self._user_id, host, port)
print('Press Ctrl-C to stop')
print('Listening...')
print()
rpc_server.serve_forever()
except KeyboardInterrupt:
pass
finally:
if rpc_server:
rpc_server.server_close()
self._server.unregister_listener(self._user_id)
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 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()
class Server(threading.Thread):
"""
Thread for incoming messages (server side of the peer)
"""
def __init__(self, peer):
threading.Thread.__init__(self)
self.loop = True
self.peer = peer
try:
self.server = SimpleXMLRPCServer((peer.IPaddr, peer.portno), allow_none=True, logRequests = False) # we change this for not show unnecessary messages
self.server.register_instance(self.peer)
except Exception as e:
print(e)
sys.exit(0)
def log(self, *msg):
print("[%s]" % self.peer.name, *msg)
def stop(self):
self.server.server_close()
self.loop = False
def run(self):
while self.loop:
#self.log("xmlrpc server is handling a request...")
self.server.handle_request()
self.log("Server Done!")
class RPCServer:
def __init__(self, addr, port, peer):
self.peer = peer
self._server = SimpleXMLRPCServer((addr, port))
self._server.register_function(self.peer.append_entry, "append_entry")
self._server.register_function(self.peer.request_vote, "request_vote")
def start(self):
server_thread = threading.Thread(target=self._server.serve_forever)
server_thread.daemn = True
server_thread.start()
def close(self):
self._server.shutdown()
self._server.server_close()
def start_server():
print('Intializing NLP engine... (this may take a while)')
nlp.init()
print('Starting HTTP server at <http://localhost:{port}>.'.format(port=PORT))
if not fork_and_daemonize():
exit(0)
server = SimpleXMLRPCServer(('localhost', PORT), allow_none=True)
server.register_function(ping)
server.register_function(query)
try:
server.serve_forever()
except:
server.server_close()
class PlayerControlProxy(object):
def __init__(self, player):
self._quit = False
self._player = player
self.server = SimpleXMLRPCServer(
(self._player.host, self._player.port),
logRequests=False,
allow_none=True)
self.server.register_instance(self, allow_dotted_names=True)
Thread(target=self.run).start()
def run(self):
while not self._quit:
self.server.handle_request()
def player_move(self, output_spec):
return self._player.player_move(output_spec)
def print_table(self, table_state):
self._player.print_table(table_state)
def join(self):
self._player.add_player()
def rejoin_new(self, ai_id='unchanged'):
self._player.rejoin_new(ai_id)
def rejoin(self, ai_type=0):
self._player.rejoin()
def get_ai_id(self):
return self._player.get_ai_id()
def get_ai_type(self):
return self._player.get_ai_type()
def save_ai_state(self):
self._player.save_ai_state()
def delete_ai(self):
self._player.delete_ai()
def quit(self):
self._player.server.remove_player(self._player.playerID)
self._quit = True
self.server.server_close()
class AuthCredentialsXMLRPCServer:
def __init__(self,
port,
student_auth_file,
prof_auth_file,
host="127.0.0.1"):
self.logger = logging.getLogger("auth.server")
self.server = SimpleXMLRPCServer((host, port), allow_none=True)
self.student_creds = self._load_creds(student_auth_file)
self.professor_creds = self._load_creds(prof_auth_file)
self.server.register_function(
self.get_prof_credentials,
"get_prof_credentials",
)
self.server.register_function(
self.get_student_credentials,
"get_student_credentials",
)
def get_prof_credentials(self):
return self.professor_creds[random.choice(
range(0, len(self.professor_creds)))]
def get_student_credentials(self):
return self.student_creds.pop()
def _load_creds(self, auth_file):
assert os.path.isfile(auth_file)
creds = list()
with open(auth_file) as fr:
for line in fr:
creds.append(line.rstrip("\n").split("\t"))
random.shuffle(creds)
return creds
def start(self):
try:
logging.info("Serving requests now")
self.server.serve_forever()
except KeyboardInterrupt:
logging.info('Keyboard interrupt received: stopping server')
finally:
self.server.server_close()
class PilotwireServer:
def __init__(self, port, debug, controller_name):
self.xmlrpc_server = SimpleXMLRPCServer(('', port), logRequests=debug)
manager = DriverManager(
namespace='pilotwire.controller',
name=controller_name,
invoke_on_load=True,
)
self.controller = manager.driver
self.xmlrpc_server.register_instance(XMLRPCMethods(self.controller))
def start(self):
self.xmlrpc_server.serve_forever()
def stop(self):
self.xmlrpc_server.shutdown()
self.xmlrpc_server.server_close()
class JcmControlServer(object):
"""RPC server, running on JCM"""
def __init__(self, address, port):
"""Initialize server with given interface address and port"""
self._address = address
self._port = port
self._server = SimpleXMLRPCServer((self._address, self._port),
logRequests=False,
allow_none=True)
# Register JCM class, all functions will be available in the client
self._server.register_instance(JCM())
# self.logger.info('Server on the JCM started successfully!')
def start(self):
"Start server"
self._server.serve_forever(0.5)
def close(self):
"Close server"
self._server.server_close()
class DispatchService:
""" Service providing access to the dispatcher """
def __init__(self, dispatcher: Dispatcher, bind_address):
self._server = SimpleXMLRPCServer(bind_address,
SimpleXMLRPCRequestHandler,
allow_none=True,
logRequests=False)
self._server.register_instance(DispatchServiceInterface(dispatcher))
def serve_forever(self):
""" Serves until shutdown """
self._server.serve_forever()
def shutdown(self):
""" Stops the serve_forever loop """
self._server.shutdown()
def server_close(self):
""" Cleans-up the server: releases all resources used by the server """
self._server.server_close()
class XMLServer:
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.is_running = False
self.server = SimpleXMLRPCServer((ip, port),
requestHandler=RequestHandler)
self.server.register_introspection_functions()
def serve_forever(self, data=None):
"""Start the server."""
if self.is_running == False:
self.is_running = True
_thread.start_new_thread(self.__serve_forever, (None, ))
def __serve_forever(self, data=None):
"""Helper to start in a thread."""
#self.server.socket.setblocking(0)
#self.server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
self.server.serve_forever()
except:
pass
def shutdown(self):
"""Shutdown and close the server."""
if self.is_running:
self.server.server_close()
self.server.socket.close()
self.is_running = False
def register_function(self, function, name=None):
"""Register a function to use with the XML RPC server."""
if name == None:
self.server.register_function(function)
else:
self.server.register_function(function, name)
class Server(Thread):
def __init__(self, host=gethostname(), port=3000):
Thread.__init__(self)
self._host = host
self._port = port
self._server = SimpleXMLRPCServer((self._host, self._port))
self._running = False
self._dict = None
self.start()
def set(self, dictionary):
self._dict = dictionary
def run(self):
self._server.register_function(lambda: True, 'ping')
def get_var(var_str):
d = self._dict
if var_str == '':
cstr = zlib.compress(pickle.dumps(d, PICKLE_PROTOCOL), 9)
else:
exec('q = d.' + var_str, locals())
var = q
if hasattr(var, 'value'): var = var.value
cstr = zlib.compress(pickle.dumps(var, PICKLE_PROTOCOL), 9)
return xmlrpclib.Binary(cstr)
self._server.register_function(get_var, 'get')
self._running = True
while self._running:
self._server.handle_request()
self._server.server_close()
def stop(self):
self._running = False
proxy = xmlrpclib.ServerProxy('http://' + self._host + ':' +
str(self._port) + '/')
proxy.ping()
class FakeNeosServer:
def __init__(self, solution):
self.service = FakeNeosService(solution)
# Create server
self.server = SimpleXMLRPCServer(
("localhost", 8000), logRequests=False)
self.server.register_introspection_functions()
self.server.register_instance(self.service)
self.server.register_multicall_functions()
self.thread = Thread(target=self.run)
self.thread.start()
def run(self):
# Run the server's main loop
self.server.serve_forever()
def stop(self):
if self.server is not None:
self.server.shutdown()
self.server.server_close()
self.server = None
class CoinpyDaemonRPCServer(object):
def __init__(self, loop: asyncio.AbstractEventLoop, node: Node,
**config: Any) -> None:
self.__io_loop = loop
self.__node = node
self.__RPCserver = None
if 'rpcbind' in config:
_, host, port = config['rpcbind']
logger.info(f'starting rpc server {(host, port)}')
self.__RPCserver = SimpleXMLRPCServer(
(host, port),
logRequests=True,
requestHandler=CoinpyDaemonRPCHandler)
# rpc procedures
def stop_daemon_cmd():
self.__io_loop.call_soon_threadsafe(self.__node.stop_sync)
return 'daemon stopped'
self.__RPCserver.register_function(stop_daemon_cmd, 'stop')
def addnode_daemon_cmd():
return 'neighbor added'
self.__RPCserver.register_function(addnode_daemon_cmd, 'addnode')
def stop(self) -> None:
if self.__RPCserver is not None:
logger.info('stopping rpc server')
self.__RPCserver.shutdown()
self.__RPCserver.server_close()
def run(self) -> None:
if self.__RPCserver is not None:
self.__io_loop.run_in_executor(None,
self.__RPCserver.serve_forever)
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 ServerThread(threading.Thread):
"""XML-RPC server thread to handle messages from CCU / Homegear"""
def __init__(self, local=LOCAL, localport=LOCALPORT):
self._local = local
self._localport = localport
LOG.debug("ServerThread.__init__")
threading.Thread.__init__(self)
# Create proxies to interact with CCU / Homegear
LOG.debug("__init__: Registering RPC methods")
self._rpcfunctions = RPCFunctions()
# 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 stop(self):
"""Shut down our XML-RPC server."""
LOG.info("Shutting down server")
self.server.shutdown()
LOG.debug("ServerThread.stop: Stopping ServerThread")
self.server.server_close()
LOG.info("Server stopped")
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
self.end = False
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.timeout = 1.0
while not self.end:
self.server.handle_request()
self.server.server_close()
def stop(self):
self.end = True
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()
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,
paramsetfile=PARAMSETFILE,
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._paramsetfile = paramsetfile
self.remotes = remotes
self.eventcallback = eventcallback
self.systemcallback = systemcallback
self.resolveparamsets = resolveparamsets
self.proxies = {}
self.failed_inits = []
self.createProxies()
if not self.proxies:
LOG.warning("No proxies available. Aborting.")
raise Exception
self._rpcfunctions = RPCFunctions(devicefile=self._devicefile,
paramsetfile=self._paramsetfile,
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")
# class SimpleThreadedXMLRPCServer(ThreadingMixIn, SimpleXMLRPCServer):
# pass
# self.server = SimpleThreadedXMLRPCServer((self._local, self._localport),
# requestHandler=RequestHandler,
# logRequests=False)
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 createProxies(self):
"""Create proxies to interact with CCU / Homegear"""
LOG.debug("createProxies: Creating proxies")
for remote, host in self.remotes.items():
# Initialize XML-RPC
try:
socket.gethostbyname(host['ip'])
except Exception as err:
LOG.warning("Skipping proxy: %s" % str(err))
continue
if 'path' not in host:
host['path'] = ''
LOG.info("Creating proxy %s. Connecting to %s:%i%s" %
(remote, host['ip'], host['port'], host['path']))
host['id'] = "%s-%s" % (self._interface_id, remote)
try:
api_url = build_api_url(host=host['ip'],
port=host['port'],
path=host['path'],
username=host.get('username'),
password=host.get('password'),
ssl=host.get('ssl'))
self.proxies[host['id']] = LockingServerProxy(
api_url,
remote=remote,
callbackip=host.get('callbackip', None),
callbackport=host.get('callbackport', None),
skipinit=not host.get('connect', True),
ssl=host.get('ssl', False),
verify_ssl=host.get('verify_ssl', True))
except Exception as err:
LOG.warning("Failed connecting to proxy at http://%s:%i%s" %
(host['ip'], host['port'], host['path']))
LOG.debug("__init__: Exception: %s" % str(err))
# pylint: disable=raise-missing-from
raise Exception
try:
host['type'] = BACKEND_UNKNOWN
#if "Homegear" in self.proxies[host['id']].getVersion():
# LOG.debug("__init__: Host is Homegear")
# host['type'] = BACKEND_HOMEGEAR
#else:
# LOG.debug("__init__: Host is CCU")
# host['type'] = BACKEND_CCU
except Exception as err:
LOG.warning("__init__: Failed to detect backend type: %s" % str(err))
host['type'] = BACKEND_UNKNOWN
def clearProxies(self):
"""Remove existing proxy objects."""
LOG.debug("clearProxies: Clearing proxies")
self.proxies.clear()
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():
if proxy._skipinit:
LOG.warning("Skipping init for %s", interface_id)
continue
if proxy._callbackip and proxy._callbackport:
callbackip = proxy._callbackip
callbackport = proxy._callbackport
else:
callbackip = proxy._localip
callbackport = self._localport
LOG.debug("ServerThread.proxyInit: init('http://%s:%i', '%s')" %
(callbackip, callbackport, interface_id))
try:
# For HomeMatic IP, init is not working correctly. We fetch the device list and create
# the device objects before the init is performed.
if proxy._remoteport in [2010, 32010, 42010]:
dev_list = proxy.listDevices(interface_id)
self._rpcfunctions.newDevices(interface_id=interface_id, dev_descriptions=dev_list)
proxy.init("http://%s:%i" %
(callbackip, callbackport), interface_id)
LOG.info("Proxy for %s initialized", interface_id)
except Exception as err:
LOG.debug("proxyInit: Exception: %s" % str(err))
LOG.warning("Failed to initialize proxy for %s", interface_id)
self.failed_inits.append(interface_id)
def proxyDeInit(self):
"""De-Init from the proxies."""
stopped = []
for interface_id, proxy in self.proxies.items():
if interface_id in self.failed_inits:
LOG.warning("ServerThread.proxyDeInit: Not performing de-init for %s", interface_id)
continue
if proxy._callbackip and proxy._callbackport:
callbackip = proxy._callbackip
callbackport = proxy._callbackport
else:
callbackip = proxy._localip
callbackport = self._localport
remote = "http://%s:%i" % (callbackip, callbackport)
LOG.debug("ServerThread.proxyDeInit: init('%s')", remote)
if not interface_id in stopped:
try:
proxy.init(remote)
stopped.append(interface_id)
LOG.info("proxyDeInit: Proxy for %s de-initialized: %s", interface_id, remote)
except Exception as err:
LOG.debug("proxyDeInit: Exception: %s", err)
LOG.warning("proxyDeInit: Failed to de-initialize proxy")
def stop(self):
"""To stop the server we de-init from the CCU / Homegear, then shut down our XML-RPC server."""
self.proxyDeInit()
self.clearProxies()
LOG.info("Shutting down server")
self.server.shutdown()
LOG.debug("ServerThread.stop: Stopping ServerThread")
self.server.server_close()
LOG.info("HomeMatic XML-RPC Server stopped")
def parseCCUSysVar(self, data):
"""Helper to parse type of system variables of CCU"""
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):
"""Login to CCU and return session"""
session = False
try:
params = {"username": self.remotes[remote][
'username'], "password": self.remotes[remote]['password']}
response = self._rpcfunctions.jsonRpcPost(
self.remotes[remote]['ip'], self.remotes[remote].get('jsonport', DEFAULT_JSONPORT), "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 of CCU"""
logout = False
try:
params = {"_session_id_": session}
response = self._rpcfunctions.jsonRpcPost(
self.remotes[remote]['ip'], self.remotes[remote].get('jsonport', DEFAULT_JSONPORT), "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'], self.remotes[remote].get('jsonport', DEFAULT_JSONPORT), "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'], self.remotes[remote].get('jsonport', DEFAULT_JSONPORT), "SysVar.getValueByName", params)
if response['error'] is None and response['result']:
try:
var = float(response['result'])
except Exception as err:
var = response['result'] == 'true'
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'], self.remotes[remote].get('jsonport', DEFAULT_JSONPORT), "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:
params['value'] = int(value)
response = self._rpcfunctions.jsonRpcPost(
self.remotes[remote]['ip'], self.remotes[remote].get('jsonport', DEFAULT_JSONPORT), "SysVar.setBool", params)
else:
response = self._rpcfunctions.jsonRpcPost(
self.remotes[remote]['ip'], self.remotes[remote].get('jsonport', DEFAULT_JSONPORT), "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))
def ping(self, remote):
"""Send ping to CCU/Homegear to generate PONG event"""
try:
self.proxies["%s-%s" % (self._interface_id, remote)].ping("%s-%s" % (self._interface_id, remote))
except Exception as err:
LOG.warning("ServerThread.ping: Exception: %s" % str(err))
def homegearCheckInit(self, remote):
"""Check if proxy is still initialized"""
rdict = self.remotes.get(remote)
if not rdict:
return False
if rdict.get('type') != BACKEND_HOMEGEAR:
return False
try:
interface_id = "%s-%s" % (self._interface_id, remote)
return self.proxies[interface_id].clientServerInitialized(interface_id)
except Exception as err:
LOG.debug(
"ServerThread.homegearCheckInit: Exception: %s" % str(err))
return False
def putParamset(self, remote, address, paramset, value, rx_mode=None):
"""Set paramsets manually"""
try:
proxy = self.proxies["%s-%s" % (self._interface_id, remote)]
if rx_mode is None:
return proxy.putParamset(address, paramset, value)
else:
return proxy.putParamset(address, paramset, value, rx_mode)
except Exception as err:
LOG.debug("ServerThread.putParamset: Exception: %s" % str(err))
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")
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))
self.proxies.clear()
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))
class FakeXMLRPCServer(object):
def __init__(self, port=TCP_PORT):
self.server = SimpleXMLRPCServer(("localhost", port))
self.server.register_function(self.applications_gettable,
'nb.Applications.getTable')
self.server.register_function(self.applications_set_loglevel,
'nb.Applications.set.logLevel')
self.server.register_function(self.applications_get_size, 'nb.Applications.size')
self.server.register_function(self.applications_find, 'nb.Applications.find')
self.server.register_function(self.applications_exists, 'nb.Applications.exists')
self.server.register_function(self.system_tables_ready, 'system.tablesReady')
self.server.register_function(self.platform_get_row, 'nb.Platform.getRow')
# self.server.register_function(self.platform_get_table, 'nb.Platform.getTable')
self.server.register_function(self.platform_get_size, 'nb.Platform.size')
self.server.register_function(self.ports_get_name, 'nb.Ports.get.name')
self.server.register_function(self.ports_get_size, 'nb.Ports.size')
self.server.register_function(self.ports_get_info, 'nb.Ports.getInfo')
self.server.register_function(self.ports_get_info_name, 'nb.Ports.getInfo.name')
self.server.register_function(self.method_help, 'system.methodHelp')
self.server.register_function(self.ports_add_row, 'nb.Ports.addRow')
self.server.register_function(self.ports_del_row, 'nb.Ports.delRow')
self.server.register_function(self.system_multicall, 'system.multicall')
self.server.register_function(self.ports_lags_get_table,
'nb.Ports2LagAdmin.getTable')
self.server.register_function(self.ports_lags_get_size, 'nb.Ports2LagAdmin.size')
self.server.register_function(self.lags_get_table, 'nb.LagsAdmin.getTable')
self.server.register_function(self.lags_get_size, 'nb.LagsAdmin.size')
self.server.register_function(self.lags_add_row, 'nb.LagsAdmin.addRow')
self.server.register_function(self.ports_lag_add_row, 'nb.Ports2LagAdmin.addRow')
self.applications = [
{'name': 'ONSApplicationServer', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'SimSwitchApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'ONSCoreServer', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'ONSNorthboundServer', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L3DhcpRelayControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2MirrorControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2QosControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2StormControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2StatsControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'ONSOpenVSwitchApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L1SfpControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2VlanControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L1PortControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2QinqControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2FdbControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2AclControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L1SwitchControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2MulticastControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2LagControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L3ControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2LldpControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
{'name': 'L2StpControlApp', 'logLevel': 'test level',
'adminState': 'Run', 'appId': 1, 'operationalState': 'Run'},
]
self.platform = [{'ethernetSwitchType': 'SimSwitch Switch',
'name': 'ONS CoreSwitch',
'cpuArchitecture': 'x86_64',
'chipVersion': '2.0',
'chipSubType': 'simswitch',
'apiVersion': 'SimSwitch 2.0.0',
'switchppVersion': '1.2.0.1405-1',
'chipName': 'SimSwitch', 'osType':
'Linux', 'model': 'ONS', 'osVersion':
'3.2.0-61-generic',
'cpu': 'x86_64',
'serialNumber': ''}]
self.ports = [
{'portId': 1, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Up', 'speed': 10000, 'name': 'xe1'},
{'portId': 2, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Up', 'speed': 10000, 'name': 'xe2'},
{'portId': 3, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Down', 'speed': 10000, 'name': 'xe3'},
{'portId': 4, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Down', 'speed': 10000, 'name': 'xe4'},
{'portId': 5, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Down', 'speed': 10000, 'name': 'xe5'},
{'portId': 6, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Down', 'speed': 10000, 'name': 'xe6'},
{'portId': 7, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Down', 'speed': 10000, 'name': 'xe7'},
{'portId': 8, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Down', 'speed': 10000, 'name': 'xe8'},
{'portId': 9, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Down', 'speed': 10000, 'name': 'xe9'},
{'portId': 10, 'adminMode': 'Up', 'pvid': 1, 'type': 'Physical',
'operationalStatus': 'Down', 'speed': 10000, 'name': 'xe10'}]
self.ports_info = {'primary_key': ['portId'],
'persistent': 'True',
'description':
'Ports table includes all type of ports in a single table.',
'columns': ['portId', 'adminMode', 'name',
'pvid', 'speed', 'operationalStatus', 'type'],
'mode': 'rw'}
self.ports_name_info = {'restrictions': {'size': '32'}, 'type': 'string',
'description': 'This ports name (a 32-byte string).',
'mode': 'ro'}
self.ports_get_row_help = 'Method for getting variable from table Ports'
self.error_multicall = False
self.lags = []
self.ports_to_lags = []
self.th = None
def start(self):
self.th = threading.Thread(target=self.server.serve_forever)
self.th.start()
def stop(self):
if self.th.is_alive():
self.server.shutdown()
self.server.server_close()
self.th.join()
def applications_gettable(self):
return self.applications
def applications_set_loglevel(self, app_id, loglevel):
if loglevel == 'error':
raise SwitchException("Error loglevel")
for row in self.applications:
if row['appId'] == app_id:
row['logLevel'] = loglevel
return 0
def applications_find(self, app_id, pid_id, app_name):
index = 0
for row in self.applications:
index += 1
if row['appId'] == app_id and row['name'] == app_name:
return index
return -1
def applications_get_size(self):
return len(self.applications)
def applications_exists(self, app_id, pid_id, app_name):
return self.applications_find(app_id, pid_id, app_name)
def system_tables_ready(self):
return 0
def platform_get_row(self, row):
row = row - 1
return self.platform[row]
def platform_get_table(self):
return self.platform
def platform_get_size(self):
return len(self.platform)
def ports_gettable(self):
return self.ports
def ports_get_name(self, row_id):
row_id = row_id - 1
return self.ports[row_id]['name']
def ports_get_size(self):
return len(self.ports)
def ports_get_info(self):
return self.ports_info
def ports_get_info_name(self):
return self.ports_name_info
def ports_add_row(self, *row):
port = {
'portId': row[0],
'adminMode': row[1],
'pvid': row[2],
'type': row[3],
'operationalStatus': row[4],
'speed': row[5],
'name': row[6],
}
self.ports.append(port)
return 0
def ports_del_row(self, row_id):
self.ports.remove(self.ports[row_id - 1])
return 0
def clear_config(self):
return 0
def method_help(self, method):
if method == 'nb.Ports.getRow':
return self.ports_get_row_help
raise SwitchException('Method %s does not exist' % (method, ))
def system_multicall(self, *calls):
res = []
for _ in calls[0]:
res.append(0)
if self.error_multicall:
return res[: -1]
return res
def ports_lags_get_table(self):
return self.ports_to_lags
def ports_lags_get_size(self):
return len(self.ports_to_lags)
def lags_get_table(self):
return self.lags
def lags_get_size(self):
return len(self.lags)
def lags_add_row(self, *row):
lag = {
'lagId': row[0],
'name': row[1],
'lagControlType': row[3],
'actorAdminLagKey': row[2],
'hashMode': row[4],
}
port = {
'portId': row[0],
'adminMode': 'Up',
'pvid': 1,
'type': 'LAG',
'operationalStatus': 'Down',
'speed': 10000,
'name': row[1],
}
self.lags.append(lag)
self.ports.append(port)
return 0
def ports_lag_add_row(self, *row):
port_lag = {
'lagId': row[1],
'portId': row[0],
'actorPortPriority': row[2],
'actorAdminPortKey': row[3],
'adminAggregation': row[4],
'adminActive': row[5],
'adminTimeout': row[6],
'adminSynchronization': row[7],
'adminCollecting': row[8],
'adminDistributing': row[9],
'adminDefaulted': row[10],
'adminExpired': row[11],
}
port = [x for x in self.ports if x['portId'] == row[0]][0]
port['type'] = 'LagMember'
self.ports_to_lags.append(port_lag)
return 0
PWMOUT = 12
GPIO.setmode(GPIO.BOARD)
GPIO.setup(PWMOUT, GPIO.OUT)
servo = GPIO.PWM(PWMOUT, 50)
servo.start(0.0)
dc = 0.0
for ii in range(5):
for dc in range(2, 14, 1):
servo.ChangeDutyCycle(dc)
time.sleep(0.1)
for dc in range(14, 2, -1):
servo.ChangeDutyCycle(dc)
time.sleep(0.1)
servo.stop()
GPIO.cleanup()
if __name__ == "__main__":
server = SimpleXMLRPCServer((SERVER, PORT), allow_none=True)
server.register_instance(SERVOFunc())
try:
server.serve_forever()
finally:
server.server_close()
sys.exit(0)
class PeerNode(Node):
port: int = None
target_host: str = None
path: str = None
target_node: Node = None
server: SimpleXMLRPCServer = None
__target_hosts: list = list()
def list_files(self, sub_path='') -> tuple:
if not sub_path:
sub_path = self.path
file_list = os.listdir(sub_path)
file_info_list: list > FileInfo = list()
for file in file_list:
if os.path.isfile(os.path.join(sub_path, file)):
file_info_list.append(
FileInfo(file, os.path.join(sub_path, file), 'file',
os.path.getsize(os.path.join(sub_path, file)),
os.path.getmtime(os.path.join(sub_path, file))))
elif os.path.isdir(os.path.join(sub_path, file)):
file_info_list.append(
FileInfo(file, os.path.join(sub_path, file), 'dir',
os.path.getsize(os.path.join(sub_path, file)),
os.path.getmtime(os.path.join(sub_path, file))))
else:
pass
return OK, file_info_list
def register(self, node) -> tuple:
if node not in self.__target_hosts:
self.__target_hosts.append(node)
return OK, SUCCESS
def configure(self, port=None, target=None, path=None) -> tuple:
if port:
self.port = port
if target:
self.target_host = target
if path:
self.path = path
return OK, SUCCESS
def connect_to_target(self) -> tuple:
self.target_node: PeerNode = ServerProxy(self.target_host,
allow_none=True)
status, message = self.target_node.register(self)
if status == OK:
LOG.info(message)
status, list_files = self.target_node.list_files()
if status == OK:
return OK, list_files
else:
return FAIL, 'get remote file list error'
else:
return FAIL, 'connect to target node failed'
def start_server(self) -> tuple:
try:
def run():
self.server = SimpleXMLRPCServer(("", self.port))
self.server.register_instance(self)
self.server.serve_forever()
thread = Thread(target=run)
thread.start()
return OK, ('server started on port : %s' % self.port)
except Exception as e:
return FAIL, e
def stop_server(self) -> tuple:
if self.server:
self.server.server_close()
return OK, 'server stop'
from xmlrpc.server import SimpleXMLRPCServer
IP_SERV = "192.168.8.170"
DEBUG_PORT = 8000
def debugFrame(frame):
frameName = frame[0]
imgArray = np.frombuffer(frame[1].data, dtype=np.uint8)
img = cv2.imdecode(imgArray, cv2.IMREAD_COLOR)
cv2.imshow(frameName, img)
#print(frame)
cv2.waitKey(10)
return 0
serverDebug = SimpleXMLRPCServer((IP_SERV, DEBUG_PORT))
serverDebug.logReqests = False
print("Control XMLRPC Server Listening on %s:%d" % (IP_SERV, DEBUG_PORT))
serverDebug.register_function(debugFrame)
try:
serverDebug.serve_forever()
except KeyboardInterrupt:
print("Ctrl+C pressed")
serverDebug.server_close()
cv2.DestroyAllWindows
#serverDebug.serve_forever()
class server():
def __init__(self, address, port, n_readers, n_writers, access):
self.address = address
self.port = int(port)
self.n_clients = int(n_readers) + int(n_writers)
self.n_access = int(access)
self.oval = -1
self.sseq = 0
self.r_ids = []
self.w_id = -1
self.rnum = 0
self.read_log = "Readers: \n\nsSeq oVal rID rNum \n\n"
self.write_log = "Writers: \n\nsSeq oVal wID \n\n"
self.mutex = threading.Lock()
self.seqmutex = threading.Lock()
self.rlogmutex = threading.Lock()
self.wlogmutex = threading.Lock()
# Start running the server
def run(self):
threading.Thread(target=self.check_server).start()
#with SimpleXMLRPCServer((self.address, self.port)) as self.server:
self.server = SimpleXMLRPCServer((self.address, self.port))
self.sock = self.server.socket
self.server.register_introspection_functions()
self.server.register_function(self.read)
self.server.register_function(self.write)
try:
self.server.serve_forever()
except KeyboardInterrupt:
exit(0)
fo = open("log", "w")
fo.write(self.read_log + "\n\n" + self.write_log)
fo.close()
def stop_server(self):
self.server.shutdown()
self.server.server_close()
def check_server(self):
while self.n_clients > self.sseq + 1:
pass
time.sleep(180)
self.stop_server()
def read(self, rid):
seq = -1
with self.seqmutex:
self.sseq += 1
seq = self.sseq
if rid not in self.r_ids:
self.r_ids.append(rid)
secs = random.randint(0, 10)
time.sleep(secs)
with self.rlogmutex:
self.read_log += str(seq) + " " + str(
self.oval) + " " + str(rid) + " " + str(len(
self.r_ids)) + "\n"
self.r_ids.remove(rid)
return self.oval, seq
def write(self, wid):
seq = -1
with self.seqmutex:
self.sseq += 1
seq = self.sseq
with self.mutex:
self.oval = wid
secs = random.randint(0, 10)
time.sleep(secs)
with self.wlogmutex:
self.write_log += str(seq) + " " + str(
self.oval) + " " + str(wid) + "\n"
return seq
class XmlRpcServer(threading.Thread):
"""Simple XMLRPC server implementation.
In theory, Python should provide a sane XMLRPC server implementation as
part of its standard library. In practice the provided implementation
doesn't handle signals, not even EINTR. As a result, we have this class.
Usage:
server = XmlRpcServer(('localhost', 43212))
server.register_delegate(my_delegate_instance)
server.run()
"""
def __init__(self, host, port):
"""Construct an XmlRpcServer.
@param host string hostname to bind to.
@param port int port number to bind to.
"""
super(XmlRpcServer, self).__init__()
logging.info('Binding server to %s:%d', host, port)
self._server = SimpleXMLRPCServer((host, port), allow_none=True)
self._server.register_introspection_functions()
self._keep_running = True
self._delegates = []
# Gracefully shut down on signals. This is how we expect to be shut
# down by autotest.
signal.signal(signal.SIGTERM, self._handle_signal)
signal.signal(signal.SIGINT, self._handle_signal)
def register_delegate(self, delegate):
"""Register delegate objects with the server.
The server will automagically look up all methods not prefixed with an
underscore and treat them as potential RPC calls. These methods may
only take basic Python objects as parameters, as noted by the
SimpleXMLRPCServer documentation. The state of the delegate is
persisted across calls.
@param delegate object Python object to be exposed via RPC.
"""
self._server.register_instance(delegate)
self._delegates.append(delegate)
def run(self):
"""Block and handle many XmlRpc requests."""
logging.info('XmlRpcServer starting...')
with contextlib.ExitStack() as stack:
for delegate in self._delegates:
stack.enter_context(delegate)
while self._keep_running:
try:
self._server.handle_request()
except select.error as v:
# In a cruel twist of fate, the python library doesn't
# handle this kind of error.
if v[0] != errno.EINTR:
raise
except Exception as e:
logging.error("Error in handle request: %s" % str(e))
logging.info('XmlRpcServer exited.')
def _handle_signal(self, _signum, _frame):
"""Handle a process signal by gracefully quitting.
SimpleXMLRPCServer helpfully exposes a method called shutdown() which
clears a flag similar to _keep_running, and then blocks until it sees
the server shut down. Unfortunately, if you call that function from
a signal handler, the server will just hang, since the process is
paused for the signal, causing a deadlock. Thus we are reinventing the
wheel with our own event loop.
"""
self._server.server_close()
self._keep_running = False
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))
class Implement(QtWidgets.QWidget, first_des.Ui_FORM):
def __init__(self):
super().__init__()
self.setupUi(self)
self.img = None
self.globl = ""
self.put_start_img()
self.thread = QThread()
self.thread.start()
self.server = SimpleXMLRPCServer(("10.42.0.1", 60002))
self.server.logRequests = False
self.server.register_function(set_msg)
self.serverControlThread = threading.Thread(
target=self.server.serve_forever)
self.serverControlThread.daemon = True
self.serverControlThread.start()
self.robot = xmlrpc.client.ServerProxy('http://%s:%d' %
("10.42.0.69", 60001))
self.spawer = Spawer(self.on_recive, self.write_msg)
self.spawer.start()
self.text.setPlaceholderText(" write here ")
#self.Button.clicked.connect(self.addText)
def on_recive(self, img):
self.imgLabel.setPixmap(QtGui.QPixmap.fromImage(img))
self.imgLabel.setAlignment(Qt.AlignHCenter # qtCore <-> QtCore
| Qt.AlignVCenter)
def write_msg(self, msg):
self.globl += msg + "\n"
#print(self.globl.count("\n"))
if (self.globl.count("\n") > 30):
ind = self.globl.find("\n")
self.globl = self.globl[ind + 1:]
self.globalLabel.setText(self.globl)
def addText(self):
if not self.text.text() == "":
text = self.text.text()
self.globl += self.text.text() + "\n"
self.text.setText("")
if (self.globl.count("\n") > 30):
ind = self.globl.find("\n")
self.globl = self.globl[ind + 1:]
self.globalLabel.setText(self.globl)
if text == "write mode":
_ = self.robot.write_mode()
if text == "read mode":
_ = self.robot.read_mode()
if text.isdigit():
_ = self.robot.set_req(text)
def put_start_img(self):
self.img = QtGui.QPixmap("img.jpg")
# self.imgLabel.setPixmap(self.img)
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self.close()
elif e.key() == Qt.Key_Return:
self.addText()
elif e.key() == Qt.Key_Enter:
self.addText()
def waiter(self):
time.sleep(10)
self.server.server_close()
QApplication.instance().quit()
def closeEvent(self, event):
reply = QtWidgets.QMessageBox.question(
self, 'Message', "Are you sure to quit?",
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
QtWidgets.QMessageBox.No)
if reply == QtWidgets.QMessageBox.Yes:
_ = self.robot.stop()
self.spawer.stop_trigger.emit()
t1 = threading.Thread(target=self.waiter)
t1.start()
event.ignore()
else:
event.ignore()
cfl = local.const_cfl
stensize = local.const_stensize
block_size = local.const_block_size
output = None
if len(sys.argv) == 3:
output = sys.argv[2]
# Get initial condition and boundary conditions from local.py (periodic boundary=True)
ic = local.init_condition()
ic = local.add_ghost_cells(ic, stensize, True)
solution = numpde.Solution(ic, block_size, stensize, True)
print("starting problem", num_cells, cfl)
p = Problem(solution, output, finish_time)
pp = ProblemProxy(p)
server = SimpleXMLRPCServer(("0.0.0.0", 8000),
logRequests=False,
allow_none=True)
# server = SimpleXMLRPCServer(("0.0.0.0", 8000), Handler)
server.register_instance(pp, allow_dotted_names=True)
server.register_introspection_functions()
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
server.server_close()
sys.exit(0)
serverControl.register_function(write_mode)
serverControl.register_function(stop)
#запускаем сервер в отдельном потоке
serverControlThread = threading.Thread(target=serverControl.serve_forever)
serverControlThread.daemon = True
serverControlThread.start()
pr = Process(target=VideoStreaming, args=(worker.q, worker.conn))
pr.start()
#главный цикл программы
import gi
from gi.repository import GObject
GObject.threads_init()
mainloop = GObject.MainLoop()
try:
#worker.pc.comReceiver("RPi: Worker started!")
mainloop.run()
except (KeyboardInterrupt, SystemExit):
print('Ctrl+C pressed')
#останов сервера
serverControl.server_close()
pr.join()
print('Program over...')
class SharedMemoryStoreServer(object):
"""The graph store server.
The server loads graph structure and node embeddings and edge embeddings
and store them in shared memory. The loaded graph can be identified by
the graph name in the input argument.
DGL graph accepts graph data of multiple formats:
* NetworkX graph,
* scipy matrix,
* DGLGraph.
If the input graph data is DGLGraph, the constructed DGLGraph only contains
its graph index.
Parameters
----------
graph_data : graph data
Data to initialize graph.
edge_dir : string
the edge direction for the graph structure ("in" or "out")
graph_name : string
Define the name of the graph, so the client can use the name to access the graph.
multigraph : bool, optional
Whether the graph would be a multigraph (default: False)
num_workers : int
The number of workers that will connect to the server.
port : int
The port that the server listens to.
"""
def __init__(self, graph_data, edge_dir, graph_name, multigraph,
num_workers, port):
self.server = None
if isinstance(graph_data, (GraphIndex, DGLGraph)):
self._graph = DGLGraph(graph_data,
multigraph=multigraph,
readonly=True)
else:
indptr, indices = _to_csr(graph_data, edge_dir, multigraph)
graph_idx = from_csr(utils.toindex(indptr), utils.toindex(indices),
multigraph, edge_dir,
_get_graph_path(graph_name))
self._graph = DGLGraph(graph_idx,
multigraph=multigraph,
readonly=True)
self._num_workers = num_workers
self._graph_name = graph_name
self._edge_dir = edge_dir
self._registered_nworkers = 0
self._barrier = BarrierManager(num_workers)
self._init_manager = InitializerManager()
# RPC command: register a graph to the graph store server.
def register(graph_name):
if graph_name != self._graph_name:
print("graph store has %s, but the worker wants %s" %
(self._graph_name, graph_name))
return (-1, -1)
worker_id = self._registered_nworkers
self._registered_nworkers += 1
return worker_id, self._num_workers
# RPC command: get the graph information from the graph store server.
def get_graph_info(graph_name):
assert graph_name == self._graph_name
# if the integers are larger than 2^31, xmlrpc can't handle them.
# we convert them to strings to send them to clients.
return str(self._graph.number_of_nodes()), str(self._graph.number_of_edges()), \
self._graph.is_multigraph, edge_dir
# RPC command: initialize node embedding in the server.
def init_ndata(init, ndata_name, shape, dtype):
if ndata_name in self._graph.ndata:
ndata = self._graph.ndata[ndata_name]
assert np.all(tuple(F.shape(ndata)) == tuple(shape))
return 0
assert self._graph.number_of_nodes() == shape[0]
init = self._init_manager.deserialize(init)
data = init(shape, dtype, _get_ndata_path(graph_name, ndata_name))
self._graph.ndata[ndata_name] = data
return 0
# RPC command: initialize edge embedding in the server.
def init_edata(init, edata_name, shape, dtype):
if edata_name in self._graph.edata:
edata = self._graph.edata[edata_name]
assert np.all(tuple(F.shape(edata)) == tuple(shape))
return 0
assert self._graph.number_of_edges() == shape[0]
init = self._init_manager.deserialize(init)
data = init(shape, dtype, _get_edata_path(graph_name, edata_name))
self._graph.edata[edata_name] = data
return 0
# RPC command: get the names of all node embeddings.
def list_ndata():
ndata = self._graph.ndata
return [[
key,
tuple(F.shape(ndata[key])), dtype_dict[F.dtype(ndata[key])]
] for key in ndata]
# RPC command: get the names of all edge embeddings.
def list_edata():
edata = self._graph.edata
return [[
key,
tuple(F.shape(edata[key])), dtype_dict[F.dtype(edata[key])]
] for key in edata]
# RPC command: notify the server of the termination of the client.
def terminate():
self._num_workers -= 1
return 0
# RPC command: a worker enters a barrier.
def enter_barrier(worker_id):
return self._barrier.enter(worker_id)
# RPC command: a worker leaves a barrier.
def leave_barrier(worker_id, barrier_id):
self._barrier.leave(worker_id, barrier_id)
return 0
# RPC command: test if all workers have left a barrier.
def all_enter(worker_id, barrier_id):
return self._barrier.all_enter(worker_id, barrier_id)
self.server = SimpleXMLRPCServer(("127.0.0.1", port),
logRequests=False)
self.server.register_function(register, "register")
self.server.register_function(get_graph_info, "get_graph_info")
self.server.register_function(init_ndata, "init_ndata")
self.server.register_function(init_edata, "init_edata")
self.server.register_function(terminate, "terminate")
self.server.register_function(list_ndata, "list_ndata")
self.server.register_function(list_edata, "list_edata")
self.server.register_function(enter_barrier, "enter_barrier")
self.server.register_function(leave_barrier, "leave_barrier")
self.server.register_function(all_enter, "all_enter")
def __del__(self):
if self.server is not None:
self.server.server_close()
self._graph = None
@property
def ndata(self):
"""Return the data view of all the nodes.
DGLGraph.ndata is an abbreviation of DGLGraph.nodes[:].data
See Also
--------
dgl.DGLGraph.nodes
"""
return NodeDataView(self._graph, ALL, self._graph_name)
@property
def edata(self):
"""Return the data view of all the edges.
DGLGraph.data is an abbreviation of DGLGraph.edges[:].data
See Also
--------
dgl.DGLGraph.edges
"""
return EdgeDataView(self._graph, ALL, self._graph_name)
def run(self):
"""Run the graph store server.
The server runs to process RPC requests from clients.
"""
while self._num_workers > 0:
self.server.handle_request()
self._graph = None
class World(object):
tile_size = 50
def __init__(self, n_agents=10, width=800, height=600):
self.running = False
self.width = width
self.height = height
self.brain = Brain()
self.server = SimpleXMLRPCServer(("localhost", 8000),
logRequests=False,
allow_none=True)
self.server.register_introspection_functions()
self.server.register_function(self.get_agents)
self.server.register_function(self.get_tiles)
self.server.register_function(self.stop)
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.tiles_x = math.ceil(self.width / self.tile_size)
self.tiles_y = math.ceil(self.height / self.tile_size)
self.tiles = [[
Tile(self, x * self.tile_size, y * self.tile_size, self.tile_size,
self.tile_size, self.tile_size) for y in range(self.tiles_y)
] for x in range(self.tiles_x)]
self.agents = []
for i in range(n_agents):
agent = Agent(self)
self.agents.append(agent)
self.agent_threads = [
threading.Thread(target=agent.run) for agent in self.agents
]
def get_tiles(self):
tiles = []
for tile in itertools.chain.from_iterable(self.tiles):
tiles.append(tile.to_dict())
return tiles
def get_agents(self):
agents = []
for agent in self.agents:
agents.append(agent.to_dict())
return agents
def run(self):
self.server_thread.start()
try:
self.running = True
for t in self.agent_threads:
t.start()
while True:
time.sleep(1)
except KeyboardInterrupt:
print("Canceled by user")
self.running = False
finally:
self.server.shutdown()
self.server.server_close()
self.server_thread.join()
for t in self.agent_threads:
t.join()
def stop(self):
self.running = False
class CloudArrayServer(object):
def __init__(self, host, port):
# self.spec = ("localhost", 9090)
self.spec = (host, port)
self.server = SimpleXMLRPCServer(self.spec)
self.server.register_function(self.stop, 'stop')
self.server.register_function(self.save_as, 'save_as')
self.server.register_function(self.rpc_for_module, 'rpc_for_module')
self.server.register_function(self.rpc_for_arrays, 'rpc_for_arrays')
self.stopped = False
self.arrays = {}
def serve(self):
print('serving on:', self.spec)
while not self.stopped:
self.server.handle_request()
self.server.server_close()
def force_stop(self):
url = 'http://%s:%s' % self.spec
with ServerProxy(url) as client:
client.stop()
def stop(self):
self.stopped = True
return 'ok'
def debug_print(self):
print('')
print('---- debug: my arrays ----')
for key, arr in self.arrays.items():
print('-', key)
print(arr)
print('')
print('-' * 40)
print('')
def random_id(self):
return 's-' + str(uuid.uuid4())
def create_cloud_array(self, arr):
cloud_arr_id = self.random_id()
self.arrays[cloud_arr_id] = arr
return cloud_arr_id
def pack_response(self, rval, bring_local):
# print('isinstance(rval, np.ndarray)?', isinstance(rval, np.ndarray))
if isinstance(rval, np.ndarray) and not bring_local:
rval = self.create_cloud_array(rval)
is_cloud_array = True
else:
is_cloud_array = False
ser_resp = util.serialize(rval)
return (ser_resp, is_cloud_array)
def save_as(self, old_id, new_id):
arr = self.arrays[old_id]
self.arrays[new_id] = arr
del self.arrays[old_id]
return 'ok'
def rpc_for_module(self, name, ser_args_data=None):
# print('name', name)
# print('server ser_args_data', ser_args_data)
if ser_args_data:
args, kwargs = util.deserialize_args(ser_args_data, self.arrays)
else:
args = []
kwargs = {}
# print('server args_data', args_data)
# args = args_data.get('args', [])
# kwargs = args_data.get('kwargs', {})
# print('args', args)
# print('kwargs', kwargs)
cloud_arr_id = self.random_id()
# print('rpc for module: %s, %s' % (cloud_arr_id, name))
rval = getattr(np, name)(*args, **kwargs)
# print('server side rval:', rval)
return self.pack_response(rval, False)
def rpc_for_arrays(self,
cloud_arr_id,
name,
access_as,
bring_local,
ser_args_data=None):
if ser_args_data:
args_data = pickle.loads(base64.b64decode(str(ser_args_data)))
else:
args_data = {}
print('SERVER: rpc for array: %s, %s' % (cloud_arr_id, name))
# print('args data:', args_data)
# self.debug_print()
arr = self.arrays[cloud_arr_id]
# print('execute the ' + name + ' function on this array:', arr)
attr = getattr(arr, name)
if access_as == 'attr':
rval = attr
elif access_as == 'method':
args = args_data.get('args', [])
kwargs = args_data.get('kwargs', {})
# print('executing %s with %s %s' % (attr, args, kwargs))
rval = attr(*args, **kwargs)
# print('packing response', rval, bring_local)
rval = self.pack_response(rval, bring_local)
# print('rval', rval)
return rval
class ServerThread(threading.Thread):
"""XML-RPC server thread to handle messages from CCU / Homegear"""
def __init__(self,
addr=(const.IP_LOCALHOST_V4, const.PORT_RF),
devices=None,
persistance=False,
logic=False):
LOG.debug("ServerThread.__init__")
threading.Thread.__init__(self)
self.addr = addr
LOG.debug("__init__: Registering RPC methods")
self._rpcfunctions = RPCFunctions(devices, persistance, logic)
LOG.debug("ServerThread.__init__: Setting up server")
self.server = SimpleXMLRPCServer(addr,
requestHandler=RequestHandler,
logRequests=False,
allow_none=True)
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.addr[0], self.addr[1])
self._rpcfunctions.active = True
self.server.serve_forever()
def stop(self):
"""Shut down our XML-RPC server."""
self._rpcfunctions.active = False
for logic_device in self._rpcfunctions.logic_devices:
logic_device.active = False
self._rpcfunctions._saveParamsets()
LOG.info("Shutting down server")
self.server.shutdown()
LOG.debug("ServerThread.stop: Stopping ServerThread")
self.server.server_close()
LOG.info("Server stopped")
# Convenience methods at server scope
def setValue(self, address, value_key, value, force=False):
return self._rpcfunctions.setValue(address, value_key, value, force)
def getValue(self, address, value_key):
return self._rpcfunctions.getValue(address, value_key)
def getDeviceDescription(self, address):
return self._rpcfunctions.getDeviceDescription(address)
def getParamsetDescription(self, address, paramset):
return self._rpcfunctions.getParamsetDescription(address, paramset)
def getParamset(self, address, paramset):
return self._rpcfunctions.getParamset(address, paramset)
def putParamset(self, address, paramset_key, paramset, force=False):
return self._rpcfunctions.putParamset(address, paramset_key, paramset,
force)
def listDevices(self):
return self._rpcfunctions.listDevices()
def getServiceMessages(self):
return self._rpcfunctions.getServiceMessages()
def supportedDevices(self):
return self._rpcfunctions.supported_devices
def addDevices(self, devices=None):
devices = self._rpcfunctions._loadDevices(devices=devices)
for interface_id, proxy in self._rpcfunctions.remotes.items():
LOG.debug("addDevices: Pushing new devices to %s", interface_id)
proxy.newDevices(interface_id, devices)
def removeDevices(self, devices=None):
self._rpcfunctions._removeDevices(devices)
