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 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()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-p",
"--port",
type=int,
default=8000,
help="listen port")
args = parser.parse_args()
port = args.port
server = SimpleXMLRPCServer(("0.0.0.0", port), allow_none=True)
server.register_function(run_python_code)
server.register_function(lambda: 'pong', 'ping')
server.register_function(lambda x, y: x + y, 'add')
server.register_function(lambda: os.kill(os.getpid(), signal.SIGTERM),
'quit')
# server.register_function(_connect, "connect")
server.register_multicall_functions()
print(f'Serving XML-RPC on localhost port {port}')
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
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 RPCServer(object):
"""
export_functions = []
export_functions.append((func1, "add"))
export_functions.append((func2, "sub"))
"""
def __init__(self, port=9999, export_functions=[], export_instance=None, name='RPC Server'):
self._port = port
self._started = False
self._export_functions = export_functions
self._export_instance = export_instance
self._name = name
def __del__(self):
self.stop()
@staticmethod
def _rpc_server_thread(rpc_server):
rpc_server._server.serve_forever()
def stop(self):
if self._started:
self._started = False
self._server.shutdown()
self._server.server_close()
def start(self, blocking=True):
if not self._started:
try:
self._server = SimpleXMLRPCServer(('127.0.0.1', self._port), logRequests=False, allow_none=True)
except socket.error as e:
pass
else:
self._server.register_multicall_functions()
for func in self._export_functions:
self._server.register_function(func[0], func[1])
if self._export_instance is not None:
self._server.register_instance(self._export_instance)
self._started = True
if not blocking:
self._thread = threading.Thread(target=RPCServer._rpc_server_thread, args=(
self,), name='%s thread' % self._name)
self._thread.daemon = True
self._thread.start()
else:
RPCServer._rpc_server_thread(self)
return self._started
def get_listening_port(self):
return self._port
def is_started(self):
return self._started
def wait_stopped(self):
if hasattr(self, '_thread'):
while self._thread.is_alive():
self._thread.join(1)
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()
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 start_server(address, port):
server = SimpleXMLRPCServer((address, port))
server.register_instance(ServerAgent(), allow_dotted_names=True)
server.register_introspection_functions()
server.register_multicall_functions()
print('Serving XML-RPC on localhost port 8000')
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting. Shutting down server.")
sys.exit(0)
def main():
#标准库提供的SimpleXMLRPCServer()相当简单，不支持其他Web页面的访问
server = SimpleXMLRPCServer(('127.0.0.1', 7001))
#register_introspection_functions()会启动一个用于自省的服务
server.register_introspection_functions()
#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 ServerThread(threading.Thread):
def __init__(self, server_addr):
threading.Thread.__init__(self)
self.server = SimpleXMLRPCServer(server_addr)
self.server.register_multicall_functions()
self.server.register_function(add, 'add')
self.server.register_function(subtract, 'subtract')
self.server.register_function(multiply, 'multiply')
self.server.register_function(divide, 'divide')
def run(self):
self.server.serve_forever()
def __init__(self):
super(ServerAgent, self).__init__()
logging.basicConfig(level=logging.DEBUG)
server = SimpleXMLRPCServer(('localhost', 9999), logRequests=True)
print("Listening on localhost:9999")
server.register_instance(self)
server.register_introspection_functions()
server.register_multicall_functions()
#server.serve_forever()
thread = threading.Thread(target=server.serve_forever)
thread.start()
print("Server thread started")
def connect(self) -> None:
server = SimpleXMLRPCServer((self.url, self.port))
logger.info(f"Listening on port {self.port}...")
server.register_function(self.get_arduino_pin_status, "arduino_pin_status")
server.register_function(self.get_arduino_dim_pin_status, "arduino_pin_dim_status")
server.register_function(self.get_arduino_status, "arduino_status")
server.register_function(self.get_dimmer_light_value, "dimmer_light_value")
server.register_function(self.test, "GET")
server.register_multicall_functions()
th = threading.Thread(target=server.serve_forever)
th.daemon = True
th.start()
def run(self):
if SETPROCTITLE:
setproctitle.setproctitle('homecontrol-homematic-event-' +
self.Index)
#XML RPC Server
srv = SimpleXMLRPCServer(('0.0.0.0', 50100 + int(self.Index)),
allow_none=True,
logRequests=False)
srv.register_introspection_functions()
srv.register_multicall_functions()
srv.register_instance(
Events(self.ComQueue, self.Settings, self.IDInternal,
self.IDExternal, self.Index))
srv.serve_forever() #BLOCKING
def create_server(bind_host='', bind_port=cfg.RPC_PORT):
"""Create an XML-RPC server instance"""
server = SimpleXMLRPCServer((bind_host, bind_port),
requestHandler=RequestHandler, allow_none=True)
server.register_introspection_functions()
# @server.register_function
server.register_function(check_object)
server.register_function(get_object)
server.register_function(list_files)
server.register_instance(Scanner(), allow_dotted_names=True)
server.register_multicall_functions()
# @server.register_function
# @server.register_function
# server.register_function(Scanner.get_n_obj_scanned)
return server
class RosMasterProxy:
"""The RosMasterProxy class implements an XMLRPC proxy server to
intercept calls to the ROS master. These calls are monitored and
documentation can be generated containing that information.
"""
def __init__(self,
nodeName,
hostname="localhost",
port=33133,
verbose=False):
"""Create a RosMasterProxy object.
* nodeName -- the name of the node to document
* hostname -- the hostname for the proxy server
* port -- the port for the proxy
* verbose -- true for verbose mode
"""
# Create the XMLRPC server
self.__server = SimpleXMLRPCServer((hostname, port),
logRequests=verbose)
# Register XMLRCP introspection methods like:
# system.listMethods, system.methodHelp and system.methodSignature
# NOTE: These are not supported by the proper ROS master
self.__server.register_introspection_functions()
# Support multi-call methods which are used by roslaunch
self.__server.register_multicall_functions()
# Register the XMLRPC functions to support the ROS master API
self.__masterFunctions = RosMasterFunctions(nodeName)
self.__server.register_instance(self.__masterFunctions)
def start(self):
"""Start the RosMasterProxy"""
# Run the server's main loop
self.__server.serve_forever()
def document(self, outputDir, docFormat=MARKDOWN):
"""Document the information pertaining to the nodes.
* outputDir -- the directory where the documentation will be output
* docFormat -- the desired format of the documentation
"""
self.__masterFunctions.document(outputDir, docFormat)
def __init__(self):
self.ip = MY_IP
if self.ip == '127.0.0.1' or self.ip == '127.0.1.1' :
self.ip = input(
'You seem to be working on Linux. I only recognise your localhost, you have to enter your IP manually: '
)
port = 8001
server = SimpleXMLRPCServer((self.ip, port), allow_none=True)
print('Listening on %s:%s' % (self.ip, port))
server.register_multicall_functions()
server.register_function(RequestServer.game_request, 'game_request')
server.register_function(RequestServer.game_is_updated, 'game_is_updated')
server.register_function(RequestServer.fetching, 'fetching')
server.register_function()
server.serve_forever()
class RPCUtilities:
"""Useful functions exposed to RPC server"""
server: Optional[SimpleXMLRPCServer] = None
def __init__(self, channel: 'TelegramChannel'):
self.channel = channel
rpc_config = self.channel.config.get('rpc')
if not rpc_config:
return
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/', '/RPC2')
server_addr = rpc_config['server']
port = rpc_config['port']
self.server = SimpleXMLRPCServer((server_addr, port),
requestHandler=RequestHandler)
self.server.register_introspection_functions()
self.server.register_multicall_functions()
self.server.register_instance(self.channel.db)
self.server.register_function(self.get_slave_channels_ids) # type: ignore
# TODO: Wait for https://github.com/python/typeshed/pull/4165 to be pushed to pypi with mypy
threading.Thread(target=self.server.serve_forever, name="ETM RPC server thread")
def shutdown(self):
"""Shutdown RPC server if running."""
if self.server:
self.server.shutdown()
@staticmethod
def get_slave_channels_ids() -> List[str]:
"""Get the collection of slave channel IDs in current instance"""
return list(coordinator.slaves.keys())
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 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")
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/PRC_Tunnel_0', )
#绑定本地端口8888 初始化server
server = SimpleXMLRPCServer(('0.0.0.0', 8888), requestHandler=RequestHandler)
server.register_introspection_functions()
#注册一个多调用组合
server.register_multicall_functions()
def add(x, y):
return x + y
def subtract(x, y):
return x - y
def multiply(x, y):
return x * y
def divide(x, y):
return x // y
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))
def run_server():
server = SimpleXMLRPCServer(('localhost', 9000))
server.register_function(pow)
server.register_function(lambda x, y: x+y, 'add')
server.register_multicall_functions()
server.serve_forever()
#!/usr/bin/python3.4
# -*- coding=utf-8 -*-
#本脚由亁颐堂现任明教教主编写，用于乾颐盾Python课程！
#教主QQ:605658506
#亁颐堂官网www.qytang.com
#乾颐盾是由亁颐堂现任明教教主开发的综合性安全课程
#包括传统网络安全（防火墙，IPS...）与Python语言和黑客渗透课程！
#参考原始文档
#https://docs.python.org/3.1/library/xmlrpc.client.html#example-of-client-and-server-usage
import datetime
from xmlrpc.server import SimpleXMLRPCServer
import xmlrpc.client
def is_even(n):#创建函数，判断奇数偶数
return n%2 == 0
def today():#创建函数，返回时间
today = datetime.datetime.today()
return xmlrpc.client.DateTime(today)
server = SimpleXMLRPCServer(("127.0.0.1", 8000))
print("Listening on port 8000...")
server.register_multicall_functions()#启动多函数注册功能！
server.register_function(is_even, "is_even")#注册函数，名字为"is_even"
server.register_function(today, "today")#注册函数，名字为"today"
server.serve_forever()#运行服务器
class RPCUtilities:
"""Useful functions exposed to RPC server"""
server: Optional[SimpleXMLRPCServer] = None
def __init__(self, channel: 'TelegramChannel'):
self.channel = channel
rpc_config = self.channel.config.get('rpc')
if not rpc_config:
return
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2', )
server_addr = rpc_config['server']
port = rpc_config['port']
self.server = SimpleXMLRPCServer((server_addr, port),
requestHandler=RequestHandler)
self.server.register_introspection_functions()
self.server.register_multicall_functions()
self.server.register_instance(self.channel.db)
self.server.register_function(self.get_slave_channels_id)
self.server.register_function(self.get_slave_channel_by_id)
self.server.register_function(self.get_chats_from_channel_by_id)
threading.Thread(target=self.server.serve_forever)
def shutdown(self):
"""Shutdown RPC server if running."""
if self.server:
self.server.shutdown()
@staticmethod
def get_slave_channels_id() -> KeysView[str]:
"""Get the collection of slave channel IDs in current instance"""
return coordinator.slaves.keys()
@staticmethod
def get_slave_channel_by_id(channel_id: ModuleID) -> Optional[EFBChannel]:
"""
Get the slave channel instance if available. Otherwise return None.
Args:
channel_id: ID of the slave channel.
"""
if channel_id in coordinator.slaves:
return coordinator.slaves[channel_id]
return None
@staticmethod
def get_chats_from_channel_by_id(
channel_id: ModuleID) -> Optional[Iterable[EFBChat]]:
"""
Get a list of chats from a specific slave channel if available.
Otherwise return None.
Args:
channel_id: ID of the slave channel.
"""
channel = RPCUtilities.get_slave_channel_by_id(channel_id)
if channel:
return channel.get_chats()
return None
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))
#!/usr/bin/env python
from xmlrpc.server import SimpleXMLRPCServer
import xmlrpc.client
import os
class ServerFunc:
def read_chat(self,file):
with open(file, 'rb') as chat:
return xmlrpc.client.Binary(chat.read())
def write_chat(self,file,user,message):
with open(file, 'a') as chat:
chat.write(user + ' says:' + message + '\n')
return 1
def ls_chats(self):
listing = str(os.listdir('.').pop(os.sys.argv[0]))
return xmlrpc.client.Binary(listing)
if __name__ == '__main__':
chat_server = SimpleXMLRPCServer(('127.0.0.1', 10000))
chat_server.register_instance(ServerFunc(),allow_dotted_names=True)
chat_server.register_function(ServerFunc().read_chat, 'read_chat')
chat_server.register_multicall_functions()
print('server is running')
chat_server.serve_forever()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from xmlrpc.server import SimpleXMLRPCServer as Server
def fak(n):
""" Berechnet die Fakultaet der ganzen Zahl n. """
erg = 1
for i in range(2, n+1):
erg *= i
return erg
def quad(n):
""" Berechnet das Quadrat der Zahl n. """
return n*n
srv = Server(("", 1337))
srv.register_function(fak)
srv.register_function(quad)
srv.register_multicall_functions()
srv.serve_forever()
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,
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)
def on_discard(result):
print("Discard: ", result)
return True
def on_finished(result):
print("Order finished:", result)
return True
if __name__ == '__main__':
orderid = count()
# start server to get the result...
server = SimpleXMLRPCServer(("localhost", 43222), logRequests=False)
print("Listening on port 43222...")
server.register_multicall_functions()
server.register_function(on_result, 'on_result')
server.register_function(on_discard, 'on_discard')
server.register_function(on_finished, 'on_finished')
thread = threading.Thread(target=server.serve_forever)
# Exit the server thread when the main thread terminates
thread.setDaemon(True)
thread.start()
s = xmlrpc.client.ServerProxy('http://localhost:45312/unisono')
# Print list of available methods
print("we do some stuff")
print(s.system.listMethods())
print(s.system.methodHelp('list_available_dataitems'))
print(s.system.methodHelp('cancel_order'))
myID = s.register_connector(43222)
class Server(object):
def __init__(self, bind='localhost', port=22617, verbose=False):
self.server = None
self.bind = bind
self.port = port
self.verbose = verbose
self.s = linuxcnc.stat()
self.c = linuxcnc.command()
def s_poll(self):
self.s.poll()
ret = {}
#for attr in ['axis', 'axes', 'estop', 'enabled', 'homed', 'interp_state']:
# ret[attr] = getattr(self.s, attr)
# AttributeError: 'linuxcnc.stat' object has no attribute '__dict__'
'''
for k, v in self.s.__dict__.iteritems():
if k.startswith('_'):
continue
if not type(v) in [int, str]:
continue
'''
for k in ['axis', 'axes', 'estop', 'enabled', 'homed', 'interp_state']:
ret[k] = getattr(self.s, k)
# dict
ret['axis'] = self.s.axis
return ret
def constants(self):
ret = {}
for k, v in linuxcnc.__dict__.items():
if k.startswith('_'):
continue
if not type(v) in [int, str]:
continue
ret[k] = v
return ret
def c_mdi(self, *args, **kwargs):
print('mdi')
print(args, kwargs)
ret = self.c.mdi(*args, **kwargs)
print(ret)
def run(self):
print('Starting server')
self.server = SimpleXMLRPCServer((self.bind, self.port),
logRequests=self.verbose,
allow_none=True)
self.server.register_introspection_functions()
self.server.register_multicall_functions()
self.server.register_instance(self)
self.server.register_function(self.c.mode, "c_mode")
self.server.register_function(self.c.wait_complete, "c_wait_complete")
#self.server.register_function(self.c.mdi, "c_mdi")
self.server.register_function(self.c_mdi, "c_mdi")
self.server.register_function(self.s.state, "s_state")
self.server.register_function(self.c.state, "c_state")
self.server.register_function(self.c.home, "c_home")
print('Running')
self.server.serve_forever()
# -*- coding=utf-8 -*-
#本脚由亁颐堂现任明教教主编写，用于乾颐盾Python课程！
#教主QQ:605658506
#亁颐堂官网www.qytang.com
#乾颐盾是由亁颐堂现任明教教主开发的综合性安全课程
#包括传统网络安全（防火墙，IPS...）与Python语言和黑客渗透课程！
#参考原始文档
#https://docs.python.org/3.1/library/xmlrpc.client.html#example-of-client-and-server-usage
import datetime
from xmlrpc.server import SimpleXMLRPCServer
import xmlrpc.client
def is_even(n): #创建函数，判断奇数偶数
return n % 2 == 0
def today(): #创建函数，返回时间
today = datetime.datetime.today()
return xmlrpc.client.DateTime(today)
server = SimpleXMLRPCServer(("127.0.0.1", 8000))
print("Listening on port 8000...")
server.register_multicall_functions() #启动多函数注册功能！
server.register_function(is_even, "is_even") #注册函数，名字为"is_even"
server.register_function(today, "today") #注册函数，名字为"today"
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))
