def makeService(self, options): rpc = TriggerXMLRPCServer(allowNone=True, useDateTime=True) xmlrpc.addIntrospection(rpc) site_factory = server.Site(rpc) # Try to setup SSL if ssl is not None: ctx = ssl.DefaultOpenSSLContextFactory(options['ssl-keyfile'], options['ssl-certfile']) xmlrpc_service = SSLServer(int(options['port']), site_factory, ctx) # Or fallback to clear-text =( else: xmlrpc_service = TCPServer(int(options['port']), site_factory) # SSH Manhole service console_service = makeConsoleService( { 'sshPort': 'tcp:%s' % options['ssh-port'], 'telnetPort': None, 'passwd': options['ssh-users'], 'namespace': { 'service': rpc, 'rebuild': rebuild, 'factory': site_factory, } } ) svc = MultiService() xmlrpc_service.setServiceParent(svc) console_service.setServiceParent(svc) return svc
def initXMLRPCServer(): """ Start the XML RPC server """ ensureXMLRPCOptions() if Hellanzb.XMLRPC_PORT == None: warn('Hellanzb.XMLRPC_PORT = None, not starting the XML-RPC server') return hxmlrpcs = HellaXMLRPCServer() xmlrpc.addIntrospection(hxmlrpcs) SECURE = True try: if SECURE: secure = HtPasswdWrapper(hxmlrpcs, 'hellanzb', Hellanzb.XMLRPC_PASSWORD, 'hellanzb XML RPC') reactor.listenTCP(Hellanzb.XMLRPC_PORT, Site(secure)) else: reactor.listenTCP(Hellanzb.XMLRPC_PORT, Site(hxmlrpcs)) except CannotListenError, cle: error(str(cle)) raise FatalError( 'Cannot bind to XML RPC port, is another hellanzb queue daemon already running?' )
def generate_manager_server(manager): '''Generate a wrapping XMLRPC server class for a given type''' class ManagerXMLRPCServer(xmlrpc.XMLRPC): _ebRender = ebRender ManagerXMLRPCServer.__name__ = '%sXMLRPCServer' % \ manager.__class__.__name__ ManagerXMLRPCServer.__doc__ = 'XMLRPC Server wrapper for %s' % \ manager.__class__.__name__ manager_server = ManagerXMLRPCServer() #Now add instancemethods for all exposed methods for attrname in dir(manager): attr = getattr(manager, attrname) if getattr(attr, XMLRPC_EXPOSE, False): wrapped = generate_wrapped_method(attr, attrname) if getattr(attr, XMLRPC_REQUIRE_AUTHENTICATION, False): setattr(wrapped, XMLRPC_REQUIRE_AUTHENTICATION, True) wrapped_name = wrapped.__name__ wrapped = new.instancemethod(wrapped, manager_server, manager_server.__class__) setattr(manager_server, wrapped_name, wrapped) xmlrpc.addIntrospection(manager_server) return manager_server
def start(): # Initiliaze MyApp app = PlotServerApp(False) # Make wx application twisted aware # Have to run "wxreactor.install()" on top before reactor.registerWxApp(app) # Make a XML-RPC Server listening on a port port = common.defaultPort # Add introspection so doc strings will show up on client side # (TODO: Adding introspection doesn't seem to work) xmlrpc.addIntrospection(app) root = resource.Resource() root.putChild('RPC2', app) #root.putChild('SOAP', app) # TODO: make it possible to pass in the interface to use, rather than # restricting it unconditionally to localhost reactor.listenTCP(port, server.Site(root), interface='127.0.0.1') # Start both reactor parts (wx MainLoop and XML-RPC server) reactor.run() # restore stdout/stderr sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__
def setUp(self): xmlrpc = Test() addIntrospection(xmlrpc) self.p = reactor.listenTCP(0, server.Site(xmlrpc), interface="127.0.0.1") self.port = self.p.getHost().port
def __init__(self, main, *args, **kwargs): self.main = main xmlrpc.XMLRPC.__init__(self, *args, **kwargs) self.putSubHandler('sync', RHTSSync(main)) self.putSubHandler('workflows', RHTSWorkflows(main)) self.putSubHandler('watchdog', RHTSWatchdog(main)) self.putSubHandler('results', RHTSResults(main)) self.putSubHandler('test', RHTSTest(main)) xmlrpc.addIntrospection(self)
def serve(main, port=3880): from twisted.internet import reactor xmlrpc.addIntrospection(main) web = static.File(params.webdir) web.putChild('RPC', main) site = server.Site(web) addListeners(reactor, site, main, port=port, logf=main.log.info) # reactor.run(installSignalHandlers=1) p = multiprocessing.Process(target=reactor.run) p.daemon = main._daemon_acquisition_process return p, main
def main(port=4118, parentpid=None): import os os.environ['NO_GAIL'] = '1' os.environ['NO_AT_BRIDGE'] = '1' import twisted gtkVersion = None try: from gi.repository import Gtk gtkVersion = Gtk._version except: pass if not gtkVersion or gtkVersion == '2.0': # As per Ubuntu 11.10, twisted glib2reactor # works with gtk2, which fails with gtk3 from twisted.internet import glib2reactor glib2reactor.install() elif gtkVersion >= '3.0': try: # Exist in Ubuntu 12.04, but not on # Ubuntu 11.10 / Fedora 16 from twisted.internet import gtk3reactor gtk3reactor.install() except: pass from twisted.internet import reactor from twisted.web import server, xmlrpc from xmlrpc_daemon import XMLRPCLdtpd import twisted.internet import socket import pyatspi import traceback _ldtp_debug = os.environ.get('LDTP_DEBUG', None) _ldtp_debug_file = os.environ.get('LDTP_DEBUG_FILE', None) try: pyatspi.setCacheLevel(pyatspi.CACHE_PROPERTIES) r = XMLRPCLdtpd() xmlrpc.addIntrospection(r) if parentpid: reactor.callWhenRunning(SignalParent(parentpid).send_later) reactor.listenTCP(port, server.Site(r)) reactor.run() except twisted.internet.error.CannotListenError: if _ldtp_debug: print(traceback.format_exc()) except socket.error: if _ldtp_debug: print(traceback.format_exc()) if _ldtp_debug_file: with open(_ldtp_debug_file, "a") as fp: fp.write(traceback.format_exc())
def setup(port): root = resource.Resource() rpcInterface = XmlRpcInterface() xmlrpc.addIntrospection(rpcInterface) root.putChild('RPC2', rpcInterface) root.putChild('peers', PeerLister()) root.putChild('list', ListQuery()) root.putChild('get', GetQuery()) #root.putChild('all', MassQuery()) factory = server.Site(root) endpoint = TCP4ServerEndpoint(reactor, port) endpoint.listen(factory)
def _register_server(self): '''Register the server on the Twisted reactor This method is split-up for unit testing sake. ''' root_server = RootServer( authenticationHandler=self._authentication_handler) xmlrpc.addIntrospection(root_server) #Create all endpoints for endpoint, manager_server in self._managers.itervalues(): root_server.putSubHandler(endpoint, manager_server) #Run reactor port = reactor.listenTCP(self._port, server.Site(root_server), interface=self._interface) return self._interface, port
def test_listMethods(self): """ A subclass of L{XMLRPC} can override C{listProcedures} to define Overriding listProcedures should prevent introspection from being broken. """ resource = TestListProcedures() addIntrospection(resource) self.createServer(resource) d = self.proxy.callRemote("system.listMethods") def listed(procedures): # The list will also include other introspection procedures added by # addIntrospection. We just want to see "foo" from our customized # listProcedures. self.assertIn('foo', procedures) d.addCallback(listed) return d
def makeService(self, options): rpc = TriggerXMLRPCServer(allowNone=True, useDateTime=True) xmlrpc.addIntrospection(rpc) site_factory = server.Site(rpc) # Try to setup SSL if ssl is not None: ctx = ssl.DefaultOpenSSLContextFactory(options['ssl-keyfile'], options['ssl-certfile']) xmlrpc_service = SSLServer(int(options['port']), site_factory, ctx, interface=options['listen-address']) # Or fallback to clear-text =( else: xmlrpc_service = TCPServer(int(options['port']), site_factory, interface=options['listen-address']) # SSH Manhole service console_service = makeConsoleService({ 'sshPort': 'tcp:%s:interface=%s' % (options['ssh-port'], options['listen-address']), 'sshKeyDir': options['ssh-keydir'], 'sshKeyName': options['ssh-keyname'], 'sshKeySize': options['ssh-keysize'], 'telnetPort': None, 'passwd': options['ssh-users'], 'namespace': { 'service': rpc, 'rebuild': rebuild, 'factory': site_factory, } }) svc = MultiService() xmlrpc_service.setServiceParent(svc) console_service.setServiceParent(svc) return svc
def main(): """To daemonize as a twistd plugin! Except this doesn't work and these""" from twisted.application.internet import TCPServer, SSLServer from twisted.application.service import Application from twisted.internet import ssl rpc = TriggerXMLRPCServer() xmlrpc.addIntrospection(rpc) server_factory = server.Site(rpc) application = Application('trigger_xmlrpc') #xmlrpc_service = TCPServer(8000, server_factory) ctx = ssl.DefaultOpenSSLContextFactory('server.key', 'cacert.pem') xmlrpc_service = SSLServer(8000, server_factory, ctx) xmlrpc_service.setServiceParent(application) return application
def __init__(self, nagios_cfg): xmlrpc.XMLRPC.__init__(self) xmlrpc.addIntrospection(self) cfg = nagios_objects.ConfigParser(nagios_cfg, ('object_cache_file', 'command_file', 'status_file', 'check_result_path')) # object types we care about: types = ('host', 'service', 'hostgroup', 'servicegroup') rawobjs = nagios_objects.ObjectParser(cfg['object_cache_file'], types) self._objects = dict([(x,{}) for x in types]) for obj in rawobjs['host']: self._objects['host'][obj['host_name']] = obj for obj in rawobjs['service']: host_name = obj['host_name'] description = obj['service_description'] if host_name not in self._objects['service']: self._objects['service'][host_name] = {} self._objects['service'][host_name][description] = obj for obj in rawobjs['hostgroup']: if obj.get('members', None): obj['members'] = obj['members'].split(',') else: obj['members'] = [] self._objects['hostgroup'][obj['hostgroup_name']] = obj for obj in rawobjs['servicegroup']: members = [] if obj.get('members', None): members_list = obj['members'].split(',') for i in xrange(0, len(members_list), 2): members.append((members_list[i], members_list[i+1])) obj['members'] = members self._objects['servicegroup'][obj['servicegroup_name']] = obj spool = spool_path(cfg['check_result_path'], 'xmlrpc') self._cmdobj = NagiosCommander(cfg['command_file'], spool) self._status_file = cfg['status_file']
def setMain(opt): """Create a MainServer class based on `opt` options""" instanceName = opt['-n'] if not instanceName: instanceName = '' print 'setMain', opt # Determine logfile path into datadir log_filename = params.log_filename if not opt.has_key( '-d') else os.path.join(opt['-d'], 'log', 'misura.log') params.log_filename = log_filename # Start the object sharing process share.init(connect=False, log_filename=log_filename) # Instantiate mainserver class main = MainServer(instanceName=instanceName, port=opt['-p'], confdir=opt['-c'], datadir=opt['-d'], plug=opt['-e'], manager=share.manager) xmlrpc.addIntrospection(main) mimetypes = {'.h5': 'application/x-hdf;subtype=bag'} static.File.contentTypes.update(mimetypes) web = static.File(params.webdir) web.putChild('RPC', main) web.putChild('data', static.File(params.datadir)) web.putChild('conf', static.File(params.confdir)) # StreamServer mdir = MisuraDirectory(main) web.putChild('stream', mdir) # Further reading about auth stuff: # http://www.tsheffler.com/blog/?p=502 realm = MisuraRealm() realm.resource = web # TODO: use also for FTP! checker = UsersChecker(main.users) portal = Portal(realm, [checker]) cred_methods = (DigestCredentialFactory("md5", "MISURA"), BasicCredentialFactory('MISURA')) wrapper = HTTPAuthSessionWrapper(portal, cred_methods) site = server.Site(wrapper) return main, web, site
def initXMLRPCServer(): """ Start the XML RPC server """ ensureXMLRPCOptions() if Hellanzb.XMLRPC_PORT == None: warn('Hellanzb.XMLRPC_PORT = None, not starting the XML-RPC server') return hxmlrpcs = HellaXMLRPCServer() xmlrpc.addIntrospection(hxmlrpcs) SECURE = True try: if SECURE: secure = HtPasswdWrapper(hxmlrpcs, 'hellanzb', Hellanzb.XMLRPC_PASSWORD, 'hellanzb XML RPC') reactor.listenTCP(Hellanzb.XMLRPC_PORT, Site(secure)) else: reactor.listenTCP(Hellanzb.XMLRPC_PORT, Site(hxmlrpcs)) except CannotListenError, cle: error(str(cle)) raise FatalError('Cannot bind to XML RPC port, is another hellanzb queue daemon already running?')
def run_siptrackd_twisted(listen_port, ssl_port, ssl_private_key, ssl_certificate, storage, reload_interval, searcher): log.msg('Creating object store') object_store = siptrackdlib.ObjectStore(storage, searcher = searcher) session_handler = sessions.SessionHandler() log.msg('Creating rpc interface') siptrackd_rpc = SiptrackdRPC(object_store, session_handler) xmlrpc.addIntrospection(siptrackd_rpc) view_rpc = view.ViewRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('view', view_rpc) view_tree_rpc = view.ViewTreeRPC(object_store, session_handler) view_rpc.putSubHandler('tree', view_tree_rpc) counter_rpc = counter.CounterRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('counter', counter_rpc) counter_loop_rpc = counter.CounterLoopRPC(object_store, session_handler) counter_rpc.putSubHandler('loop', counter_loop_rpc) user_rpc = user.UserRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('user', user_rpc) user_local_rpc = user.UserLocalRPC(object_store, session_handler) user_rpc.putSubHandler('local', user_local_rpc) user_ldap_rpc = user.UserLDAPRPC(object_store, session_handler) user_rpc.putSubHandler('ldap', user_ldap_rpc) user_active_directory_rpc = user.UserActiveDirectoryRPC(object_store, session_handler) user_rpc.putSubHandler('activedirectory', user_active_directory_rpc) user_rpc.putSubHandler('ad', user_active_directory_rpc) user_manager_rpc = user.UserManagerRPC(object_store, session_handler) user_rpc.putSubHandler('manager', user_manager_rpc) user_manager_local_rpc = user.UserManagerLocalRPC(object_store, session_handler) user_manager_rpc.putSubHandler('local', user_manager_local_rpc) user_manager_ldap_rpc = user.UserManagerLDAPRPC(object_store, session_handler) user_manager_rpc.putSubHandler('ldap', user_manager_ldap_rpc) user_manager_active_directory_rpc = user.UserManagerActiveDirectoryRPC(object_store, session_handler) user_manager_rpc.putSubHandler('activedirectory', user_manager_active_directory_rpc) user_manager_rpc.putSubHandler('ad', user_manager_active_directory_rpc) user_group_rpc = user.UserGroupRPC(object_store, session_handler) user_rpc.putSubHandler('group', user_group_rpc) user_group_ldap_rpc = user.UserGroupLDAPRPC(object_store, session_handler) user_group_rpc.putSubHandler('ldap', user_group_ldap_rpc) user_group_active_directory_rpc = user.UserGroupActiveDirectoryRPC(object_store, session_handler) user_group_rpc.putSubHandler('activedirectory', user_group_active_directory_rpc) user_group_rpc.putSubHandler('ad', user_group_active_directory_rpc) device_rpc = device.DeviceRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('device', device_rpc) device_tree_rpc = device.DeviceTreeRPC(object_store, session_handler) device_rpc.putSubHandler('tree', device_tree_rpc) device_category_rpc = device.DeviceCategoryRPC(object_store, session_handler) device_rpc.putSubHandler('category', device_category_rpc) device_config_rpc = deviceconfig.DeviceConfigRPC(object_store, session_handler) device_rpc.putSubHandler('config', device_config_rpc) device_config_template_rpc = deviceconfig.DeviceConfigTemplateRPC(object_store, session_handler) device_config_rpc.putSubHandler('template', device_config_template_rpc) password_rpc = password.PasswordRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('password', password_rpc) password_key_rpc = password.PasswordKeyRPC(object_store, session_handler) password_rpc.putSubHandler('key', password_key_rpc) password_tree_rpc = password.PasswordTreeRPC(object_store, session_handler) password_rpc.putSubHandler('tree', password_tree_rpc) password_category_rpc = password.PasswordCategoryRPC(object_store, session_handler) password_rpc.putSubHandler('category', password_category_rpc) sub_key_rpc = password.SubKeyRPC(object_store, session_handler) password_rpc.putSubHandler('subkey', sub_key_rpc) network_rpc = network.NetworkRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('network', network_rpc) network_tree_rpc = network.NetworkTreeRPC(object_store, session_handler) network_rpc.putSubHandler('tree', network_tree_rpc) network_ipv4_rpc = network.NetworkIPV4RPC(object_store, session_handler) network_rpc.putSubHandler('ipv4', network_ipv4_rpc) network_range_rpc = network.NetworkRangeRPC(object_store, session_handler) network_rpc.putSubHandler('range', network_range_rpc) network_range_ipv4_rpc = network.NetworkRangeIPV4RPC(object_store, session_handler) network_range_rpc.putSubHandler('ipv4', network_range_ipv4_rpc) network_ipv6_rpc = network.NetworkIPV6RPC(object_store, session_handler) network_rpc.putSubHandler('ipv6', network_ipv6_rpc) network_range_ipv6_rpc = network.NetworkRangeIPV6RPC(object_store, session_handler) network_range_rpc.putSubHandler('ipv6', network_range_ipv6_rpc) container_rpc = container.ContainerRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('container', container_rpc) container_tree_rpc = container.ContainerTreeRPC(object_store, session_handler) container_rpc.putSubHandler('tree', container_tree_rpc) attribute_rpc = attribute.AttributeRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('attribute', attribute_rpc) versioned_attribute_rpc = attribute.VersionedAttributeRPC(object_store, session_handler) attribute_rpc.putSubHandler('versioned', versioned_attribute_rpc) encrypted_attribute_rpc = attribute.EncryptedAttributeRPC( object_store, session_handler ) attribute_rpc.putSubHandler( 'encrypted', encrypted_attribute_rpc ) template_rpc = template.TemplateRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('template', template_rpc) device_template_rpc = template.DeviceTemplateRPC(object_store, session_handler) template_rpc.putSubHandler('device', device_template_rpc) network_template_rpc = template.NetworkTemplateRPC(object_store, session_handler) template_rpc.putSubHandler('network', network_template_rpc) template_rule_rpc = template.TemplateRuleRPC(object_store, session_handler) template_rpc.putSubHandler('rule', template_rule_rpc) template_rule_password_rpc = template.TemplateRulePasswordRPC(object_store, session_handler) template_rule_rpc.putSubHandler('password', template_rule_password_rpc) template_rule_assign_network_rpc = template.TemplateRuleAssignNetworkRPC(object_store, session_handler) template_rule_rpc.putSubHandler('assign_network', template_rule_assign_network_rpc) template_rule_subdevice_rpc = template.TemplateRuleSubdeviceRPC(object_store, session_handler) template_rule_rpc.putSubHandler('subdevice', template_rule_subdevice_rpc) template_rule_text_rpc = template.TemplateRuleTextRPC(object_store, session_handler) template_rule_rpc.putSubHandler('text', template_rule_text_rpc) template_rule_fixed_rpc = template.TemplateRuleFixedRPC(object_store, session_handler) template_rule_rpc.putSubHandler('fixed', template_rule_fixed_rpc) template_rule_regmatch_rpc = template.TemplateRuleRegmatchRPC(object_store, session_handler) template_rule_rpc.putSubHandler('regmatch', template_rule_regmatch_rpc) template_rule_bool_rpc = template.TemplateRuleBoolRPC(object_store, session_handler) template_rule_rpc.putSubHandler('bool', template_rule_bool_rpc) template_rule_int_rpc = template.TemplateRuleIntRPC(object_store, session_handler) template_rule_rpc.putSubHandler('int', template_rule_int_rpc) template_rule_delete_attribute_rpc = template.TemplateRuleDeleteAttributeRPC(object_store, session_handler) template_rule_rpc.putSubHandler('delete_attribute', template_rule_delete_attribute_rpc) template_rule_flush_nodes_rpc = template.TemplateRuleFlushNodesRPC(object_store, session_handler) template_rule_rpc.putSubHandler('flush_nodes', template_rule_flush_nodes_rpc) template_rule_flush_associations_rpc = template.TemplateRuleFlushAssociationsRPC(object_store, session_handler) template_rule_rpc.putSubHandler('flush_associations', template_rule_flush_associations_rpc) config_rpc = config.ConfigRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('config', config_rpc) config_network_autoassign_rpc = config.ConfigNetworkAutoassignRPC(object_store, session_handler) config_rpc.putSubHandler('network_autoassign', config_network_autoassign_rpc) config_value_rpc = config.ConfigValueRPC(object_store, session_handler) config_rpc.putSubHandler('value', config_value_rpc) simple_rpc = simple.SimpleRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('simple', simple_rpc) permission_rpc = permission.PermissionRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('permission', permission_rpc) command_rpc = event.CommandRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('command', command_rpc) command_queue_rpc = event.CommandQueueRPC(object_store, session_handler) command_rpc.putSubHandler('queue', command_queue_rpc) event_rpc = event.EventRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('event', event_rpc) event_trigger_rpc = event.EventTriggerRPC(object_store, session_handler) event_rpc.putSubHandler('trigger', event_trigger_rpc) event_trigger_rule_rpc = event.EventTriggerRuleRPC(object_store, session_handler) event_trigger_rpc.putSubHandler('rule', event_trigger_rule_rpc) event_trigger_rule_python_rpc = event.EventTriggerRulePythonRPC(object_store, session_handler) event_trigger_rule_rpc.putSubHandler('python', event_trigger_rule_python_rpc) root_service = service.MultiService() if listen_port: siptrackd_xmlrpc_service = internet.TCPServer(listen_port, server.Site(siptrackd_rpc)) siptrackd_xmlrpc_service.setServiceParent(root_service) if ssl_port: ssl_context = SiptrackOpenSSLContextFactory(ssl_private_key, ssl_certificate) siptrackd_ssl_xmlrpc_service = internet.SSLServer(ssl_port, server.Site(siptrackd_rpc), ssl_context) siptrackd_ssl_xmlrpc_service.setServiceParent(root_service) application = service.Application('siptrackd') root_service.setServiceParent(application) reactor.callWhenRunning(siptrackd_twisted_init, object_store, application) if reload_interval: reactor.callLater(reload_interval, object_store_reloader, session_handler, object_store, reload_interval) reactor.run() log.msg('Shutting down siptrackd server.') return 0
if __name__ == '__main__': import datetime import random import ConfigParser config = ConfigParser.RawConfigParser(allow_no_value=True) config.read('config.ini') if not config.get('log', 'filename'): log.startLogging(sys.stdout) else: log.startLogging(logfile.DailyLogFile( config.get('log', 'filename'), config.get('log', 'path'))) log.msg("try to connect sqlite") dbpool = adbapi.ConnectionPool( 'sqlite3', config.get('sqlite', 'db_file'), check_same_thread=False) dbpool.runInteraction(initTables) log.msg("try to init service") from twisted.internet import reactor root = resource.Resource() rpc = MyServer() xmlrpc.addIntrospection(rpc) root.putChild(config.get('service', 'mount_point'), rpc) reactor.listenTCP(config.getint('service', 'port'), server.Site(root)) log.msg( "service listened on port http://0.0.0.0:%s/%s" % (config.getint('service', 'port'), config.get('service', 'mount_point'))) reactor.run()
) # except: if 1 == 2: cb.complete( ["Error", "query_bars(%s) failed!" % repr((bar_symbol, bar_period, bar_start, bar_end)), "Count: 0"] ) def handle_historical_data(self, msg): for cb in self.bardata_callbacks: if cb.id == msg.reqId: if not cb.data: cb.data = [] if msg.date.startswith("finished"): cb.complete(["OK", cb.data]) else: cb.data.append(dict(msg.items())) # self.output('historical_data: %s' % msg) #repr((id, start_date, bar_open, bar_high, bar_low, bar_close, bar_volume, count, WAP, hasGaps))) def query_connection_status(self): return self.connection_status if __name__ == "__main__": log.startLogging(sys.stdout) tws = TWS() reactor.listenTCP(tws.tcp_port, serverFactory(tws)) xmlsvr = xmlserver(tws) xmlrpc.addIntrospection(xmlsvr) reactor.listenTCP(tws.xmlrpc_port, server.Site(xmlsvr)) reactor.run()
def getClientConnectionService(): global client_connection_manager xmlrpc.addIntrospection(client_connection_manager) site = server.Site(client_connection_manager) return internet.TCPServer(9090, site, interface="127.0.0.1")
def run_siptrackd_twisted(listen_port, ssl_port, ssl_private_key, ssl_certificate, storage, reload_interval, searcher): log.msg('Creating object store') object_store = siptrackdlib.ObjectStore(storage, searcher=searcher) session_handler = sessions.SessionHandler() log.msg('Creating rpc interface') siptrackd_rpc = SiptrackdRPC(object_store, session_handler) xmlrpc.addIntrospection(siptrackd_rpc) view_rpc = view.ViewRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('view', view_rpc) view_tree_rpc = view.ViewTreeRPC(object_store, session_handler) view_rpc.putSubHandler('tree', view_tree_rpc) counter_rpc = counter.CounterRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('counter', counter_rpc) counter_loop_rpc = counter.CounterLoopRPC(object_store, session_handler) counter_rpc.putSubHandler('loop', counter_loop_rpc) user_rpc = user.UserRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('user', user_rpc) user_local_rpc = user.UserLocalRPC(object_store, session_handler) user_rpc.putSubHandler('local', user_local_rpc) user_ldap_rpc = user.UserLDAPRPC(object_store, session_handler) user_rpc.putSubHandler('ldap', user_ldap_rpc) user_active_directory_rpc = user.UserActiveDirectoryRPC( object_store, session_handler) user_rpc.putSubHandler('activedirectory', user_active_directory_rpc) user_rpc.putSubHandler('ad', user_active_directory_rpc) user_manager_rpc = user.UserManagerRPC(object_store, session_handler) user_rpc.putSubHandler('manager', user_manager_rpc) user_manager_local_rpc = user.UserManagerLocalRPC(object_store, session_handler) user_manager_rpc.putSubHandler('local', user_manager_local_rpc) user_manager_ldap_rpc = user.UserManagerLDAPRPC(object_store, session_handler) user_manager_rpc.putSubHandler('ldap', user_manager_ldap_rpc) user_manager_active_directory_rpc = user.UserManagerActiveDirectoryRPC( object_store, session_handler) user_manager_rpc.putSubHandler('activedirectory', user_manager_active_directory_rpc) user_manager_rpc.putSubHandler('ad', user_manager_active_directory_rpc) user_group_rpc = user.UserGroupRPC(object_store, session_handler) user_rpc.putSubHandler('group', user_group_rpc) user_group_ldap_rpc = user.UserGroupLDAPRPC(object_store, session_handler) user_group_rpc.putSubHandler('ldap', user_group_ldap_rpc) user_group_active_directory_rpc = user.UserGroupActiveDirectoryRPC( object_store, session_handler) user_group_rpc.putSubHandler('activedirectory', user_group_active_directory_rpc) user_group_rpc.putSubHandler('ad', user_group_active_directory_rpc) device_rpc = device.DeviceRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('device', device_rpc) device_tree_rpc = device.DeviceTreeRPC(object_store, session_handler) device_rpc.putSubHandler('tree', device_tree_rpc) device_category_rpc = device.DeviceCategoryRPC(object_store, session_handler) device_rpc.putSubHandler('category', device_category_rpc) device_config_rpc = deviceconfig.DeviceConfigRPC(object_store, session_handler) device_rpc.putSubHandler('config', device_config_rpc) device_config_template_rpc = deviceconfig.DeviceConfigTemplateRPC( object_store, session_handler) device_config_rpc.putSubHandler('template', device_config_template_rpc) password_rpc = password.PasswordRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('password', password_rpc) password_key_rpc = password.PasswordKeyRPC(object_store, session_handler) password_rpc.putSubHandler('key', password_key_rpc) password_tree_rpc = password.PasswordTreeRPC(object_store, session_handler) password_rpc.putSubHandler('tree', password_tree_rpc) password_category_rpc = password.PasswordCategoryRPC( object_store, session_handler) password_rpc.putSubHandler('category', password_category_rpc) sub_key_rpc = password.SubKeyRPC(object_store, session_handler) password_rpc.putSubHandler('subkey', sub_key_rpc) network_rpc = network.NetworkRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('network', network_rpc) network_tree_rpc = network.NetworkTreeRPC(object_store, session_handler) network_rpc.putSubHandler('tree', network_tree_rpc) network_ipv4_rpc = network.NetworkIPV4RPC(object_store, session_handler) network_rpc.putSubHandler('ipv4', network_ipv4_rpc) network_range_rpc = network.NetworkRangeRPC(object_store, session_handler) network_rpc.putSubHandler('range', network_range_rpc) network_range_ipv4_rpc = network.NetworkRangeIPV4RPC( object_store, session_handler) network_range_rpc.putSubHandler('ipv4', network_range_ipv4_rpc) network_ipv6_rpc = network.NetworkIPV6RPC(object_store, session_handler) network_rpc.putSubHandler('ipv6', network_ipv6_rpc) network_range_ipv6_rpc = network.NetworkRangeIPV6RPC( object_store, session_handler) network_range_rpc.putSubHandler('ipv6', network_range_ipv6_rpc) container_rpc = container.ContainerRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('container', container_rpc) container_tree_rpc = container.ContainerTreeRPC(object_store, session_handler) container_rpc.putSubHandler('tree', container_tree_rpc) attribute_rpc = attribute.AttributeRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('attribute', attribute_rpc) versioned_attribute_rpc = attribute.VersionedAttributeRPC( object_store, session_handler) attribute_rpc.putSubHandler('versioned', versioned_attribute_rpc) encrypted_attribute_rpc = attribute.EncryptedAttributeRPC( object_store, session_handler) attribute_rpc.putSubHandler('encrypted', encrypted_attribute_rpc) template_rpc = template.TemplateRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('template', template_rpc) device_template_rpc = template.DeviceTemplateRPC(object_store, session_handler) template_rpc.putSubHandler('device', device_template_rpc) network_template_rpc = template.NetworkTemplateRPC(object_store, session_handler) template_rpc.putSubHandler('network', network_template_rpc) template_rule_rpc = template.TemplateRuleRPC(object_store, session_handler) template_rpc.putSubHandler('rule', template_rule_rpc) template_rule_password_rpc = template.TemplateRulePasswordRPC( object_store, session_handler) template_rule_rpc.putSubHandler('password', template_rule_password_rpc) template_rule_assign_network_rpc = template.TemplateRuleAssignNetworkRPC( object_store, session_handler) template_rule_rpc.putSubHandler('assign_network', template_rule_assign_network_rpc) template_rule_subdevice_rpc = template.TemplateRuleSubdeviceRPC( object_store, session_handler) template_rule_rpc.putSubHandler('subdevice', template_rule_subdevice_rpc) template_rule_text_rpc = template.TemplateRuleTextRPC( object_store, session_handler) template_rule_rpc.putSubHandler('text', template_rule_text_rpc) template_rule_fixed_rpc = template.TemplateRuleFixedRPC( object_store, session_handler) template_rule_rpc.putSubHandler('fixed', template_rule_fixed_rpc) template_rule_regmatch_rpc = template.TemplateRuleRegmatchRPC( object_store, session_handler) template_rule_rpc.putSubHandler('regmatch', template_rule_regmatch_rpc) template_rule_bool_rpc = template.TemplateRuleBoolRPC( object_store, session_handler) template_rule_rpc.putSubHandler('bool', template_rule_bool_rpc) template_rule_int_rpc = template.TemplateRuleIntRPC( object_store, session_handler) template_rule_rpc.putSubHandler('int', template_rule_int_rpc) template_rule_delete_attribute_rpc = template.TemplateRuleDeleteAttributeRPC( object_store, session_handler) template_rule_rpc.putSubHandler('delete_attribute', template_rule_delete_attribute_rpc) template_rule_flush_nodes_rpc = template.TemplateRuleFlushNodesRPC( object_store, session_handler) template_rule_rpc.putSubHandler('flush_nodes', template_rule_flush_nodes_rpc) template_rule_flush_associations_rpc = template.TemplateRuleFlushAssociationsRPC( object_store, session_handler) template_rule_rpc.putSubHandler('flush_associations', template_rule_flush_associations_rpc) config_rpc = config.ConfigRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('config', config_rpc) config_network_autoassign_rpc = config.ConfigNetworkAutoassignRPC( object_store, session_handler) config_rpc.putSubHandler('network_autoassign', config_network_autoassign_rpc) config_value_rpc = config.ConfigValueRPC(object_store, session_handler) config_rpc.putSubHandler('value', config_value_rpc) simple_rpc = simple.SimpleRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('simple', simple_rpc) permission_rpc = permission.PermissionRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('permission', permission_rpc) command_rpc = event.CommandRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('command', command_rpc) command_queue_rpc = event.CommandQueueRPC(object_store, session_handler) command_rpc.putSubHandler('queue', command_queue_rpc) event_rpc = event.EventRPC(object_store, session_handler) siptrackd_rpc.putSubHandler('event', event_rpc) event_trigger_rpc = event.EventTriggerRPC(object_store, session_handler) event_rpc.putSubHandler('trigger', event_trigger_rpc) event_trigger_rule_rpc = event.EventTriggerRuleRPC(object_store, session_handler) event_trigger_rpc.putSubHandler('rule', event_trigger_rule_rpc) event_trigger_rule_python_rpc = event.EventTriggerRulePythonRPC( object_store, session_handler) event_trigger_rule_rpc.putSubHandler('python', event_trigger_rule_python_rpc) root_service = service.MultiService() if listen_port: siptrackd_xmlrpc_service = internet.TCPServer( listen_port, server.Site(siptrackd_rpc)) siptrackd_xmlrpc_service.setServiceParent(root_service) if ssl_port: ssl_context = SiptrackOpenSSLContextFactory(ssl_private_key, ssl_certificate) siptrackd_ssl_xmlrpc_service = internet.SSLServer( ssl_port, server.Site(siptrackd_rpc), ssl_context) siptrackd_ssl_xmlrpc_service.setServiceParent(root_service) application = service.Application('siptrackd') root_service.setServiceParent(application) reactor.callWhenRunning(siptrackd_twisted_init, object_store, application) if reload_interval: reactor.callLater(reload_interval, object_store_reloader, session_handler, object_store, reload_interval) reactor.run() log.msg('Shutting down siptrackd server.') return 0
self.loop.start(0.1) def scan_exi(self): """ First scan the EXI Check answers to make sure we do not use an EXIID that is already used by a real EXI """ self.exid = defer.Deferred() self.exi = 1 def scanNext(): if self.exi >= 16: self.exiloop.stop() self.exid.callback(None) packet = [35, 00, 11, 2, CMD['EXI_ECHO_REQUEST']] packet[1] = self.exi + EXIOFFSET self.send_command(self.exi + EXIOFFSET, CMD['EXI_ECHO_REQUEST']) self.exi += 1 self.exiloop = LoopingCall(scanNext) self.exiloop.start(0.1) if __name__ == '__main__': from twisted.internet import reactor morbidq_factory = MorbidQClientFactory() ws = WebService() ws.morbidq_factory = morbidq_factory xmlrpc.addIntrospection(ws) reactor.listenTCP( 8000, server.Site(ws) ) reactor.connectTCP(MORBIDQ_HOST, MORBIDQ_PORT, morbidq_factory) reactor.run()
if 1 == 2: cb.complete([ 'Error', 'query_bars(%s) failed!' % repr( (bar_symbol, bar_period, bar_start, bar_end)), 'Count: 0' ]) def handle_historical_data(self, msg): for cb in self.bardata_callbacks: if cb.id == msg.reqId: if not cb.data: cb.data = [] if msg.date.startswith('finished'): cb.complete(['OK', cb.data]) else: cb.data.append(dict(msg.items())) #self.output('historical_data: %s' % msg) #repr((id, start_date, bar_open, bar_high, bar_low, bar_close, bar_volume, count, WAP, hasGaps))) def query_connection_status(self): return self.connection_status if __name__ == '__main__': log.startLogging(sys.stdout) tws = TWS() reactor.listenTCP(tws.tcp_port, serverFactory(tws)) xmlsvr = xmlserver(tws) xmlrpc.addIntrospection(xmlsvr) reactor.listenTCP(tws.xmlrpc_port, server.Site(xmlsvr)) reactor.run()
from twisted.application import internet, service from twisted.web import xmlrpc, server from twisted.internet import reactor from txtrader.tws import TWS from txtrader.xmlserver import xmlserver from txtrader.tcpserver import serverFactory msvc = service.MultiService() api=TWS() xrs = xmlserver(api) xmlrpc.addIntrospection(xrs) internet.TCPServer(api.xmlrpc_port, server.Site(xrs)).setServiceParent(msvc) internet.TCPServer(api.tcp_port, serverFactory(api)).setServiceParent(msvc) application = service.Application('txtrader') msvc.setServiceParent(application) reactor.run()
# file: xmlrpcserver.py from twisted.web import server, resource, xmlrpc #1 from twisted.internet import reactor import plain_pi #2 class PiMaker(xmlrpc.XMLRPC): #3 def xmlrpc_pi(self, n): #4 return plain_pi.piPlain(n) xmlrpc_pi.signature = [['int'], ['double']] #5 xmlrpc_pi.help = 'Calculate pi with Monte ' \ 'Carlo method.' #6 pimaker = PiMaker() #7 xmlrpc.addIntrospection(pimaker) #8 siteRoot = resource.Resource() #9 siteRoot.putChild('', pimaker) #10 reactor.listenTCP(8888, server.Site(siteRoot)) #11 reactor.run()
# --------------------------------------------------------------------------- from twisted.web import xmlrpc, server class Example(xmlrpc.XMLRPC): """An example object to be published.""" def xmlrpc_echo(self, x): """Return all passed args.""" return x ##xmlrpc_echo.signature = [['string', 'string'], ##['int', 'int'], ##['double', 'double'], ##['array', 'array'], ##['struct', 'struct']] def xmlrpc_add(self, a, b): """Return sum of arguments.""" return a + b ##xmlrpc_add.signature = [['int', 'int', 'int'], ##['double', 'double', 'double']] ##xmlrpc_add.help = "Add the arguments and return the sum." if __name__ == '__main__': from twisted.internet import reactor r = Example() xmlrpc.addIntrospection(r) reactor.listenTCP(7080, server.Site(r)) reactor.run()
def setUp(self): xmlrpc = Test() addIntrospection(xmlrpc) self.p = reactor.listenTCP(0, server.Site(xmlrpc),interface="127.0.0.1") self.port = self.p.getHost().port self.factories = []
def put_child(self, folder, rpc, add_introspection=False): if add_introspection: self.sub_services.append([folder, rpc]) xmlrpc.addIntrospection(rpc) self.putChild(folder, rpc)