def __init__(self, relayport, transitport, advertise_version, db_url=":memory:", blur_usage=None): service.MultiService.__init__(self) self._blur_usage = blur_usage self.db = get_db(db_url) welcome = { "current_version": __version__, # adding .motd will cause all clients to display the message, # then keep running normally #"motd": "Welcome to the public relay.\nPlease enjoy this service.", # # adding .error will cause all clients to fail, with this message #"error": "This server has been disabled, see URL for details.", } if advertise_version: welcome["current_version"] = advertise_version self.root = Root() site = PrivacyEnhancedSite(self.root) if blur_usage: site.logRequests = False r = endpoints.serverFromString(reactor, relayport) self.relayport_service = ServerEndpointService(r, site) self.relayport_service.setServiceParent(self) self.relay = Relay(self.db, welcome, blur_usage) # accessible from tests self.root.putChild(b"wormhole-relay", self.relay) if transitport: self.transit = Transit(self.db, blur_usage) self.transit.setServiceParent(self) # for the timer t = endpoints.serverFromString(reactor, transitport) self.transport_service = ServerEndpointService(t, self.transit) self.transport_service.setServiceParent(self)
def main(): config = ConfigParser.ConfigParser() config.read(os.path.expanduser('~/.b07')) api = b07.api.API(reactor, config.get('ingress', 'email'), config.get('ingress', 'password')) http_root = Redirect('https://localhost:{}/'.format(config.get('server', 'https_port'))) http_factory = Site(http_root) http_endpoint = endpoints.serverFromString(reactor, 'tcp:{}'.format(config.get('server', 'http_port'))) http_endpoint.listen(http_factory) https_root = File(os.path.expanduser(config.get('server', 'web_root'))) https_root.indexNames = ['index.html'] https_factory = Site(https_root) https_endpoint = endpoints.serverFromString(reactor, 'ssl:{}:privateKey={}:certKey={}'.format(config.get('server', 'https_port'), os.path.expanduser(config.get('server', 'ssl_key')), os.path.expanduser(config.get('server', 'ssl_cert')))) https_endpoint.listen(https_factory) wsfactory = Factory() wsfactory.protocol = WebSocketProtocol wss_endpoint = endpoints.serverFromString(reactor, 'ssl:{}:privateKey={}:certKey={}'.format(config.get('server', 'wss_port'), os.path.expanduser(config.get('server', 'ssl_key')), os.path.expanduser(config.get('server', 'ssl_cert')))) wss_endpoint.listen(txws.WebSocketFactory(wsfactory)) reactor.run()
def __init__(self, reactor, cap_table, http_endpoint, ws_endpoint, root_cap, title): # Constants self.__http_endpoint_string = str(http_endpoint) self.__http_endpoint = endpoints.serverFromString(reactor, self.__http_endpoint_string) self.__ws_endpoint = endpoints.serverFromString(reactor, str(ws_endpoint)) self.__visit_path = _make_cap_url(root_cap) wcommon = WebServiceCommon( reactor=reactor, title=title, ws_endpoint_string=ws_endpoint) # TODO: Create poller actually for the given reactor w/o redundancy -- perhaps there should be a one-poller-per-reactor map subscription_context = SubscriptionContext(reactor=reactor, poller=the_poller) def resource_factory(entry_point): # TODO: If not an IWebEntryPoint, return a generic result return IWebEntryPoint(entry_point).get_entry_point_resource(wcommon=wcommon) # pylint: disable=redundant-keyword-arg server_root = CapAccessResource(cap_table=cap_table, resource_factory=resource_factory) _put_root_static(wcommon, server_root) if UNIQUE_PUBLIC_CAP in cap_table: # TODO: consider factoring out "generate URL for cap" server_root.putChild('', Redirect(_make_cap_url(UNIQUE_PUBLIC_CAP))) self.__ws_protocol = txws.WebSocketFactory( FactoryWithArgs.forProtocol(OurStreamProtocol, cap_table, subscription_context)) self.__site = _SiteWithHeaders(server_root) self.__ws_port_obj = None self.__http_port_obj = None
def main(): log.startLogging(sys.stdout) startPort = 3000 lastServerEndpoint = 'tcp:interface=127.0.0.1:%s' % startPort torAgent = TorAgent(reactor) serverEndpoint = serverFromString(reactor, lastServerEndpoint) connectDeferred = serverEndpoint.listen(AgentProxyFactory(torAgent)) endpoint = [] agent = [] for x in range(10): endpoint = clientFromString(reactor, "tcp:127.0.0.1:%s" % (startPort + x)) proxyAgent = ProxyAgent(endpoint) serverEndpoint = serverFromString(reactor, "tcp:interface=127.0.0.1:%s" % (startPort + x + 1)) connectDeferred = serverEndpoint.listen(AgentProxyFactory(proxyAgent)) # XXX def clientConnectionFailed(factory, reason): log.err(reason) log.err("httpTorProxy: clientConnectionFailed") connectDeferred.addErrback(clientConnectionFailed) reactor.run()
def coerce_to_server_endpoint(reactor, ep_descr): """Given a string, attempt to produce a server endpoint. If the string describes an endpoint directly, we use that; otherwise, assume it's an attempt to provide a TCP endpoint and try variations on that in the hope that one is parseable. Parameters ---------- reactor : `implements twisted.internet.interfaces.IReactorCore` Twisted reactor to use in constructing endpoint. ep_descr : `str` String describing the desired endpoint. """ try: # Maybe this already is a valid endpoint. return serverFromString(reactor, ep_descr) except (ValueError, TypeError): pass try: # Assume it just needs "tcp:" prepended. return serverFromString(reactor, f"tcp:{ep_descr}") except (ValueError, TypeError): # At this point, we'll give up, and go back to the original bad parse. serverFromString(reactor, ep_descr)
def postOptions(self): strport = self['strport'] factoryIdentifier = self['factory-identifier'] if strport is None or factoryIdentifier is None: self.opt_help() store = self.parent.parent.getStore() storeID = int(factoryIdentifier) try: factory = store.getItemByID(storeID) except KeyError: print "%d does not identify an item." % (storeID,) raise SystemExit(1) else: if not IProtocolFactoryFactory.providedBy(factory): print "%d does not identify a factory." % (storeID,) raise SystemExit(1) else: description = self.decodeCommandLine(strport) try: serverFromString(reactor, description.encode('ascii')) except ValueError: print "%r is not a valid port description." % (strport,) raise SystemExit(1) port = StringEndpointPort( store=store, description=description, factory=factory) installOn(port, store) print "Created." raise SystemExit(0)
def main(self, reactor, options): certificates_path = FilePath(options["certificates-directory"]) ca = Certificate.loadPEM( certificates_path.child(b"cluster.crt").getContent()) # This is a hack; from_path should be more # flexible. https://clusterhq.atlassian.net/browse/FLOC-1865 control_credential = ControlCredential.from_path( certificates_path, b"service") top_service = MultiService() persistence = ConfigurationPersistenceService( reactor, options["data-path"]) persistence.setServiceParent(top_service) cluster_state = ClusterStateService(reactor) cluster_state.setServiceParent(top_service) api_service = create_api_service( persistence, cluster_state, serverFromString( reactor, options["port"]), rest_api_context_factory(ca, control_credential)) api_service.setServiceParent(top_service) amp_service = ControlAMPService( reactor, cluster_state, persistence, serverFromString( reactor, options["agent-port"]), amp_server_context_factory(ca, control_credential)) amp_service.setServiceParent(top_service) return main_for_service(reactor, top_service)
def __init__(self, reactor, cap_table, read_only_dbs, writable_db, http_endpoint, ws_endpoint, root_cap, title, flowgraph_for_debug): # Constants self.__http_endpoint_string = http_endpoint self.__http_endpoint = endpoints.serverFromString(reactor, http_endpoint) self.__ws_endpoint = endpoints.serverFromString(reactor, ws_endpoint) self.__visit_path = _make_cap_url(root_cap) wcommon = WebServiceCommon(ws_endpoint_string=ws_endpoint) def BoundSessionResource(session): return SessionResource(session, wcommon, reactor, title, read_only_dbs, writable_db, flowgraph_for_debug) server_root = CapAccessResource(cap_table=cap_table, resource_ctor=BoundSessionResource) _put_root_static(server_root) if UNIQUE_PUBLIC_CAP in cap_table: # TODO: consider factoring out "generate URL for cap" server_root.putChild('', Redirect(_make_cap_url(UNIQUE_PUBLIC_CAP))) self.__ws_protocol = txws.WebSocketFactory( FactoryWithArgs.forProtocol(OurStreamProtocol, cap_table)) self.__site = _SiteWithHeaders(server_root) self.__ws_port_obj = None self.__http_port_obj = None
def main(): options = docopt.docopt(__doc__) port = int(options['<port>']) rate = float(options['<rate>']) label = options['<label>'] endpoints.serverFromString(reactor, "tcp:%d" % port).listen(SampleFactory(rate, label)) reactor.run()
def born(self, data): """Method initiate TCL and UDP listeners.""" lc = LoopingCall(get_metrics, None) lc.start(2) reactor.listenUDP(self.UDP_PORT, NotificationUDPProcessor()) reactor.listenMulticast(self.MULTICAST_PORT, MunticastNotificationProcessor(self.MULTICAST_IP), # add multicast 'born' processing listenMultiple=True) endpoints.serverFromString(reactor, "tcp:21999").listen(EchoFactory())
def do_listen(self, addr): if not hasattr(self, "isClient") or not self.isClient: self.isClient = False else: self.error("this is a client, doesn't support listen") return self._readHistoryFile('.peagunServer') serverFromString(reactor, addr).listen(self.connectionManager)
def start(): game = MultisnakeServer() server_update = task.LoopingCall(game.update) server_update.start(1.0) endpoints.serverFromString(reactor, "tcp:1234").listen(PlayerConnectionFactory(game)) reactor.run()
def __init__(self, rendezvous_web_port, transit_port, advertise_version, db_url=":memory:", blur_usage=None, signal_error=None): service.MultiService.__init__(self) self._blur_usage = blur_usage db = get_db(db_url) welcome = { # The primary (python CLI) implementation will emit a message if # its version does not match this key. If/when we have # distributions which include older version, but we still expect # them to be compatible, stop sending this key. "current_cli_version": __version__, # adding .motd will cause all clients to display the message, # then keep running normally #"motd": "Welcome to the public relay.\nPlease enjoy this service.", # adding .error will cause all clients to fail, with this message #"error": "This server has been disabled, see URL for details.", } if advertise_version: welcome["current_cli_version"] = advertise_version if signal_error: welcome["error"] = signal_error rendezvous = Rendezvous(db, welcome, blur_usage) rendezvous.setServiceParent(self) # for the pruning timer root = Root() wsrf = WebSocketRendezvousFactory(None, rendezvous) root.putChild(b"v1", WebSocketResource(wsrf)) site = PrivacyEnhancedSite(root) if blur_usage: site.logRequests = False r = endpoints.serverFromString(reactor, rendezvous_web_port) rendezvous_web_service = ServerEndpointService(r, site) rendezvous_web_service.setServiceParent(self) if transit_port: transit = Transit(db, blur_usage) transit.setServiceParent(self) # for the timer t = endpoints.serverFromString(reactor, transit_port) transit_service = ServerEndpointService(t, transit) transit_service.setServiceParent(self) # make some things accessible for tests self._db = db self._rendezvous = rendezvous self._root = root self._rendezvous_web_service = rendezvous_web_service self._rendezvous_websocket = wsrf if transit_port: self._transit = transit self._transit_service = transit_service
def serve_forever(port=9999): """Process incoming requests from the given socket. :param port: The port to listen on :type port: int """ endpoints.serverFromString(reactor, "tcp:{}".format(port)).listen( MemcachedProtocolFactory() ) reactor.run()
def start_server(): factory = KnowledgeFactory() endpoints.serverFromString( reactor, "tcp:%s" % config.SERVER_PORT).listen(factory) logging.info("server started on port %d", config.SERVER_PORT) reactor.run() reactor.callLater(100, reactor.stop) logging.info("server execution ended")
def main(amqp_host, max_vms, intf): #_install_sig_handlers() virt_ip = netifaces.ifaddresses('virbr2')[2][0]['addr'] endpoints.serverFromString(reactor, "tcp:55555:interface={}".format(virt_ip)).listen(GuestCommsFactory()) slave = Slave.instance(amqp_host, max_vms, intf) reactor.callWhenRunning(slave.start) reactor.addSystemEventTrigger("during", "shutdown", Slave.instance().stop) reactor.run()
def create_endpoint_services(reactor, parent, listen_endpoints, factory): for listen_endpoint in listen_endpoints: # work around http://twistedmatrix.com/trac/ticket/8422 if sys.version_info.major < 3: endpoint = endpoints.serverFromString(reactor, listen_endpoint.encode('utf-8')) else: endpoint = endpoints.serverFromString(reactor, listen_endpoint) service = internet.StreamServerEndpointService(endpoint, factory) # FIXME: Use addService on parent ? service.setServiceParent(parent)
def start_http(): #http in reactor root = Resource() root.putChild("register", RegisterHTTP()) root.putChild("data", ICBCHTTP()) endpoints.serverFromString(reactor, "tcp:8000").listen(server.Site(root)) #tcp in reactor ICBCEndpoint = endpoints.serverFromString(reactor, "tcp:8800") ICBCEndpoint.listen(ICBCFactory()) #start the reactor reactor.run(installSignalHandlers=0)
def startService(self): if self.port_s is not None: endpoint = serverFromString(reactor, self.port_s) d = endpoint.listen(self.site) d.addCallback(self.register_port, 'app') if self.authInfoEndpointStr is not None: authInfoApp = AuthInfoApp() self.authInfoApp = authInfoApp authInfoSite = Site(authInfoApp.app.resource()) endpoint = serverFromString(reactor, self.authInfoEndpointStr) d2 = endpoint.listen(authInfoSite) d2.addCallback(self.register_port, 'authInfoSite')
def main(): bind_address = "0.0.0.0" gateway_port = 5001 logger.debug("start gateway server(%s:%d)" % (bind_address, gateway_port)) # reactor.listenTCP(gateway_port, GatewayFactory(), 100, bind_address) endpoints.serverFromString(reactor, "tcp:%d" % gateway_port).listen(GatewayFactory()) try: reactor.run() except KeyboardInterrupt: logger.error("stop gateway server")
def start_reactor(): cp = ConfigParser.SafeConfigParser() cp.read('config\config.ini') #http in reactor root = Resource() root.putChild("data", ICBCHTTP()) endpoints.serverFromString(reactor, "tcp:" + str(cp.get('server', 'http_server_port'))).listen(server.Site(root)) #tcp in reactor ICBCEndpoint = endpoints.serverFromString(reactor, "tcp:" + str(cp.get('server', 'tcp_server_port'))) ICBCEndpoint.listen(ICBCFactory()) #start the reactor logger.info("Reactor has started.") reactor.run(installSignalHandlers=0)
def initialize(self): print ('Initializing the world...') # Accept new players. endpoints.serverFromString(reactor, "tcp:8799").listen(WorldSessionFactory(self)) # Start the heartbeat self.heartbeat.start(self.heartbeat_delay) # Call the CLI handler. reactor.callInThread(self.CLI) print ('World initialized.')
def startService(self): debug = self.debug factory = Balancer(self.hostports, self.netmap) factory.debug = debug admin_portal = self.admin_portal admin_endpoint = self.admin_endpoint if admin_portal is not None and admin_endpoint is not None: admin_service, admin_website = make_ws(admin_portal, factory) ep = serverFromString(reactor, admin_endpoint) d0 = ep.listen(admin_service) d0.addCallback(self.set_listening_port, port_type='admin') ep = serverFromString(reactor, self.endpoint) d = ep.listen(factory) d.addCallback(self.set_listening_port, port_type='proxy')
def main(reactor, server_endpoint_string, handoff_endpoint_string): logger.globalLogBeginner.beginLoggingTo( [logger.textFileLogObserver(sys.stderr)]) server_endpoint = endpoints.serverFromString( reactor, server_endpoint_string) server_port = yield server_endpoint.listen(AlwaysAbortFactory()) handoff_factory = HandoffFactory(server_port, describe_socket(server_port.socket)) reactor.removeReader(server_port) handoff_endpoint = endpoints.serverFromString( reactor, handoff_endpoint_string) yield handoff_endpoint.listen(handoff_factory) yield defer.Deferred()
def main(self, reactor, options): top_service = MultiService() persistence = ConfigurationPersistenceService( reactor, options["data-path"]) persistence.setServiceParent(top_service) cluster_state = ClusterStateService() cluster_state.setServiceParent(top_service) create_api_service(persistence, cluster_state, serverFromString( reactor, options["port"])).setServiceParent(top_service) amp_service = ControlAMPService( cluster_state, persistence, serverFromString( reactor, options["agent-port"])) amp_service.setServiceParent(top_service) return main_for_service(reactor, top_service)
def setup_module(module): """ setup any state specific to the execution of the given module.""" global b_handler, a_handler, t # blueflood server mock b_handler = http_server_mock.MockServerHandler() # auth server mock a_handler = http_server_mock.MockServerHandler() endpoints.serverFromString(reactor, "tcp:8000").listen(server.Site(b_handler)) endpoints.serverFromString(reactor, "tcp:8001").listen(server.Site(a_handler)) t = threading.Thread(target=reactor.run, args=(0, )) t.daemon = True t.start()
def run(self): logger.info("Twisted " + self.getName() + " Start Running") # http in reactor root = Resource() root.putChild("data", ICBCHTTP()) root.putChild("register", RegisterHTTP()) endpoints.serverFromString(reactor, "tcp:" + self.http_port).listen(server.Site(root)) logger.info("HTTP Server listen on port: " + self.http_port) # tcp in reactor ICBCEndpoint = endpoints.serverFromString(reactor, "tcp:" + self.tcp_port) ICBCEndpoint.listen(ICBCFactory()) logger.info("TCP Server listen on port: " + self.tcp_port) # start the reactor logger.info("Reactor has started.") reactor.run(installSignalHandlers=0)
def clean(self, value): from twisted.internet.endpoints import serverFromString from twisted.internet import reactor try: return serverFromString(reactor, value) except ValueError: self.raise_config_error('is not a valid server endpoint')
def test_parse_relative_path(self): # this makes sure we convert a relative path to absolute # hiddenServiceDir args. see Issue #77 # make sure we have a valid thing from get_global_tor without # actually launching tor config = TorConfig() config.post_bootstrap = defer.succeed(config) from txtorcon import torconfig torconfig._global_tor_config = None get_global_tor( self.reactor, _tor_launcher=lambda react, config, prog: defer.succeed(config) ) orig = os.path.realpath('.') try: with util.TempDir() as t: t = str(t) os.chdir(t) os.mkdir(os.path.join(t, 'foo')) hsdir = os.path.join(t, 'foo', 'blam') os.mkdir(hsdir) ep = serverFromString( self.reactor, 'onion:88:localPort=1234:hiddenServiceDir=foo/blam' ) self.assertEqual( os.path.realpath(hsdir), ep.hidden_service_dir ) finally: os.chdir(orig)
def __init__(self, basedir, reactor): service.MultiService.__init__(self) self._basedir = basedir self._reactor = reactor root = Root() site = server.Site(root) ep = endpoints.serverFromString(reactor, "tcp:8220") internet.StreamServerEndpointService(ep, site).setServiceParent(self) self._jm = journal.JournalManager(self._save_state) root.putChild(b"", static.Data("root", "text/plain")) root.putChild(b"list-invitations", Status(self._list_invitations)) root.putChild(b"invite", Action(self._invite)) # {petname:} root.putChild(b"accept", Action(self._accept)) # {petname:, code:} self._state_fn = os.path.join(self._basedir, "state.json") self._state = State.from_filename(self._state_fn) self._wormholes = {} for iid, invitation_state in self._state.get_all_invitations().items(): def _dispatch(event, *args, **kwargs): self._dispatch_wormhole_event(iid, event, *args, **kwargs) w = wormhole.journaled_from_data(invitation_state["wormhole"], reactor=self._reactor, journal=self._jm, event_handler=self, event_handler_args=(iid,)) self._wormholes[iid] = w w.setServiceParent(self)
def onJoin(self, details): # regs = [] yield self.register(rpc_bdata, u'ru.bustime.rpc_bdata') yield self.register(rpc_passenger, u'ru.bustime.rpc_passenger') # mobile support only yield self.register(rpc_bootstrap_amounts, u'ru.bustime.rpc_bootstrap_amounts') yield self.register(rpc_tcard, u'ru.bustime.rpc_tcard') yield self.register(rpc_stop_ids, u'ru.bustime.rpc_stop_ids') def accept(offers): for offer in offers: if isinstance(offer, PerMessageDeflateOffer): return PerMessageDeflateOfferAccept(offer) if __name__ == '__main__': router_factory = wamp.RouterFactory() session_factory = wamp.RouterSessionFactory(router_factory) component_config = types.ComponentConfig(realm="realm1") component_session = MyBackendComponent(component_config) session_factory.add(component_session) transport_factory = websocket.WampWebSocketServerFactory(session_factory, debug=False, debug_wamp=False) server = serverFromString(reactor, "tcp:%s" % PORT) server.listen(transport_factory) reactor.run()
def connectionLost(self, reason): self.factory.clients.remove(self) def lineReceived(self, line): for c in self.factory.clients: source = u"<{}> ".format(self.transport.getHost()).encode("ascii") c.sendLine(source + line) class PubFactory(protocol.Factory): def __init__(self): self.clients = set() def buildProtocol(self, addr): return PubProtocol(self) if __name__ == '__main__': parser = argparse.ArgumentParser( description='Socket Server Example with Epoll') parser.add_argument('--port', action="store", dest="port", type=int, required=True) given_args = parser.parse_args() port = given_args.port endpoints.serverFromString(reactor, "tcp:%s" % port).listen(PubFactory()) reactor.run()
action="store_true", help="Enable debug output.") parser.add_argument( "--endpoint", default="tcp:8080", help= 'WebSocket server Twisted endpoint descriptor, e.g. "tcp:127.0.0.1:8080" or "unix:/tmp/mywebsocket".' ) parser.add_argument( "--url", default=u"ws://localhost:8080/ws", help= 'WebSocket URL (must suit the endpoint), e.g. ws://localhost:8080/ws.') args = parser.parse_args() if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') factory = WebSocketServerFactory(args.url, reactor=reactor) factory.protocol = MyServerProtocol server = serverFromString(reactor, args.endpoint) server.listen(factory) reactor.run()
def __init__(self, rendezvous_web_port, transit_port, advertise_version, db_url=":memory:", blur_usage=None, signal_error=None, stats_file=None, allow_list=True): service.MultiService.__init__(self) self._blur_usage = blur_usage self._allow_list = allow_list db = get_db(db_url) welcome = { # The primary (python CLI) implementation will emit a message if # its version does not match this key. If/when we have # distributions which include older version, but we still expect # them to be compatible, stop sending this key. "current_cli_version": __version__, # adding .motd will cause all clients to display the message, # then keep running normally #"motd": "Welcome to the public relay.\nPlease enjoy this service.", # adding .error will cause all clients to fail, with this message #"error": "This server has been disabled, see URL for details.", } if advertise_version: welcome["current_cli_version"] = advertise_version if signal_error: welcome["error"] = signal_error self._rendezvous = Rendezvous(db, welcome, blur_usage, self._allow_list) self._rendezvous.setServiceParent(self) # for the pruning timer root = Root() wsrf = WebSocketRendezvousFactory(None, self._rendezvous) root.putChild(b"v1", WebSocketResource(wsrf)) site = PrivacyEnhancedSite(root) if blur_usage: site.logRequests = False r = endpoints.serverFromString(reactor, rendezvous_web_port) rendezvous_web_service = internet.StreamServerEndpointService(r, site) rendezvous_web_service.setServiceParent(self) if transit_port: transit = Transit(db, blur_usage) transit.setServiceParent(self) # for the timer t = endpoints.serverFromString(reactor, transit_port) transit_service = internet.StreamServerEndpointService(t, transit) transit_service.setServiceParent(self) self._stats_file = stats_file if self._stats_file and os.path.exists(self._stats_file): os.unlink(self._stats_file) # this will be regenerated immediately, but if something goes # wrong in dump_stats(), it's better to have a missing file than # a stale one t = internet.TimerService(EXPIRATION_CHECK_PERIOD, self.timer) t.setServiceParent(self) # make some things accessible for tests self._db = db self._root = root self._rendezvous_web_service = rendezvous_web_service self._rendezvous_websocket = wsrf self._transit = None if transit_port: self._transit = transit self._transit_service = transit_service
def create_listening_endpoint_from_config(config, cbdir, reactor, log): """ Create a Twisted stream server endpoint from a Crossbar.io transport configuration. See: https://twistedmatrix.com/documents/current/api/twisted.internet.interfaces.IStreamServerEndpoint.html :param config: The transport configuration. :type config: dict :param cbdir: Crossbar.io node directory (we need this for TLS key/certificates). :type cbdir: str :param reactor: The reactor to use for endpoint creation. :type reactor: obj :returns obj -- An instance implementing IStreamServerEndpoint """ endpoint = None # a TCP endpoint # if config['type'] == 'tcp': # the TCP protocol version (v4 or v6) # version = int(config.get('version', 4)) # the listening port if type(config['port']) is six.text_type: # read port from environment variable .. try: port = int(environ[config['port'][1:]]) except Exception as e: log.warn("Could not read listening port from env var: {e}", e=e) raise else: port = config['port'] # the listening interface # interface = str(config.get('interface', '').strip()) # the TCP accept queue depth # backlog = int(config.get('backlog', 50)) if 'tls' in config: # create a TLS server endpoint # if _HAS_TLS: # TLS server context context = _create_tls_server_context(config['tls'], cbdir, log) if version == 4: endpoint = SSL4ServerEndpoint(reactor, port, context, backlog=backlog, interface=interface) elif version == 6: raise Exception("TLS on IPv6 not implemented") else: raise Exception("invalid TCP protocol version {}".format(version)) else: raise Exception("TLS transport requested, but TLS packages not available:\n{}".format(_LACKS_TLS_MSG)) else: # create a non-TLS server endpoint # if version == 4: endpoint = TCP4ServerEndpoint(reactor, port, backlog=backlog, interface=interface) elif version == 6: endpoint = TCP6ServerEndpoint(reactor, port, backlog=backlog, interface=interface) else: raise Exception("invalid TCP protocol version {}".format(version)) # a Unix Domain Socket endpoint # elif config['type'] == 'unix': # the accept queue depth # backlog = int(config.get('backlog', 50)) # the path # path = FilePath(join(cbdir, config['path'])) # if there is already something there, delete it. # if path.exists(): log.info(("{path} exists, attempting to remove before using as a " "UNIX socket"), path=path) path.remove() # create the endpoint # endpoint = UNIXServerEndpoint(reactor, path.path, backlog=backlog) # twisted endpoint-string elif config['type'] == 'twisted': endpoint = serverFromString(reactor, config['server_string']) else: raise Exception("invalid endpoint type '{}'".format(config['type'])) return endpoint
from twisted.internet import protocol, reactor, defer, utils, endpoints from twisted.protocols import basic class FingerProtocol(basic.LineReceiver): def lineReceived(self, user): d = self.factory.getUser(user) def onError(err): return b'Internal error in server' d.addErrback(onError) def writeResponse(message): self.transport.write(b'writeResponse:') self.transport.write(message + b'\r\n') self.transport.loseConnection() d.addCallback(writeResponse) class FingerFactory(protocol.ServerFactory): protocol = FingerProtocol def getUser(self, user): return utils.getProcessOutput(b"finger", [user]) fingerEndpoint = endpoints.serverFromString(reactor, "tcp:1079") fingerEndpoint.listen(FingerFactory()) reactor.run()
def start(self): self.endpoint = endpoints.serverFromString(reactor, self.options.endpoint) self.endpoint.listen(self.site)
if __name__ == '__main__': import argparse parser = argparse.ArgumentParser( description='Starts a new pubsub broker hub for the ping protocol') parser.add_argument('--port', metavar='P', type=int, help='Port to listen', default=1026) parser.add_argument('--ip', dest='ip', help='ip to listen', default="127.0.0.1") parser.add_argument('--dest_port', type=int, help='Port to connect', default=1025) parser.add_argument('--dest_ip', dest='dest_ip', help='ip to connect', default="127.0.0.1") args = parser.parse_args() endpoints.serverFromString( reactor, "tcp:interface=%s:port=%s" % (args.ip, args.port)).listen( BrokerPubFactory(args.dest_ip, args.dest_port)) reactor.run()
#! /bin/env python3 from twisted.web import server, resource from twisted.internet import reactor, endpoints class Counter(resource.Resource): isLeaf = True numberRequests = 0 def render_GET(self, request): # self.numberRequests += 1 # request.setHeader(b"content-type", b"text/plain") content = "" return content.encode("ascii") endpoints.serverFromString(reactor, "tcp:5555").listen(server.Site(Counter())) reactor.run()
#req_args['master'][0], req_args['num_nodes'][0], req_args['cores'][0]) elif 'explore' in req_args.keys(): self.start_exploration(req_args['target_cpus'][0]) elif 'exploit' in req_args.keys(): self.start_exploitation(req_args['num_jobs'][0]) else: print("not understood") return "OK" ################################################## def render_GET(self, request): # self.numberRequests += 1 a = request.args print(a) to_ret = self.parse_handle_req(a) request.setHeader(b"content-type", b"text/plain") content = to_ret return content.encode("ascii") ################################################## endpoints.serverFromString(reactor, "tcp:7878").listen(server.Site(evlisten())) reactor.run()
from twisted.internet import reactor, protocol, endpoints from twisted.protocols import basic class PubProtocol(basic.LineReceiver): def __init__(self, factory): self.factory = factory def connectionMade(self): self.factory.clients.add(self) def connectionLost(self, reason): self.factory.clients.remove(self) def lineReceived(self, line): for c in self.factory.clients: source = u"<{}> ".format(self.transport.getHost()).encode("ascii") c.sendLine(source + line) class PubFactory(protocol.Factory): def __init__(self): self.clients = set() def buildProtocol(self, addr): return PubProtocol(self) endpoints.serverFromString(reactor, "tcp:1025").listen(PubFactory()) reactor.run()
def main(opts): global games games = load_games(opts) ep = "tcp:%d" % (opts.port, ) endpoints.serverFromString(reactor, ep).listen(server.Site(root)) reactor.run()
import datetime import httplib2 from twisted.web import server, resource from twisted.internet import reactor, endpoints class Health(resource.Resource): isLeaf = True def render_GET(self, request): request.responseHeaders.addRawHeader("content-type", "application/json") print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') + ' SideCar健康检查') return '{"status":"UP"}'.encode('utf-8') root = Health() root.putChild('health', Health()) endpoints.serverFromString(reactor, "tcp:port=5680").listen(server.Site(root)) reactor.run()
def main(reactor, listenOn="stdio:"): endpoint = serverFromString(reactor, listenOn) endpoint.listen(factoryFromFlow(echoFlow)) return Deferred()
"--web", default="tcp:8080", help='Web server endpoint descriptor, e.g. "tcp:8080".') args = parser.parse_args() # start Twisted logging to stdout log.startLogging(sys.stdout) # we use an Autobahn utility to install the "best" available Twisted reactor from autobahn.twisted.choosereactor import install_reactor reactor = install_reactor() print("Running on reactor {}".format(reactor)) # start a WebSocket server wsfactory = EchoServerFactory(args.wsurl) wsserver = serverFromString(reactor, args.websocket) wsserver.listen(wsfactory) # start a Web server if args.web != "": from twisted.web.server import Site from twisted.web.static import File webfactory = Site(File(".")) webserver = serverFromString(reactor, args.web) webserver.listen(webfactory) # now enter the Twisted reactor loop reactor.run()
res['msg'] = mems res['status'] = True if isinstance(res, dict): request.setHeader("Content-Type", "application/json;charset=UTF-8") res = json.dumps(res) elif path.startswith('/v1/wxspider/img/'): request.setHeader('Content-Type', 'image/jpeg') else: request.setHeader('Content-Type', 'text/html') return res def cleanup(): for client in CLIENTS.itervalues(): client.cleanup() if __name__ == '__main__': from twisted.web.server import Site from twisted.internet import endpoints endpoints.serverFromString(reactor, "tcp:%s:interface=%s" % (8087, INNER_IP)).listen(Site(TaskManage())) init_clients() for c in CLIENTS.itervalues(): c.run() task.LoopingCall(check_clients).start(40, now=False) reactor.addSystemEventTrigger('before', 'shutdown', cleanup) reactor.run()
def test_minimal(self): embedded_components, client_components = [], [ Case2_Backend, Case2_Frontend ] ## create a WAMP router factory ## from autobahn.wamp.router import RouterFactory router_factory = RouterFactory() ## create a WAMP router session factory ## from autobahn.twisted.wamp import RouterSessionFactory session_factory = RouterSessionFactory(router_factory) ## .. and create and add an WAMP application session to ## run next to the router ## from autobahn.wamp import types config = types.ComponentConfig(realm=self.realm, extra={'caselog': 'case1.log'}) try: log = io.open('caselog.log', 'w') print "WWW" * 10, log except Exception as e: print "X" * 10, e # log = io.open(config.extra['caselog'], 'w') config.log = log config.dlog = [] config.components = [] config.all_done = [] for C in embedded_components: one_done = Deferred() config.all_done.append(one_done) c = C(config, one_done) config.components.append(c) session_factory.add(c) print "2" * 10 if self.transport == "websocket": ## create a WAMP-over-WebSocket transport server factory ## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory( session_factory, debug_wamp=self.debug) transport_factory.setProtocolOptions(failByDrop=False, openHandshakeTimeout=0, closeHandshakeTimeout=0) elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport server factory ## if self.transport == 'rawsocket-msgpack': from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() elif self.transport == 'rawsocket-json': from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() else: raise Exception("should not arrive here") from autobahn.twisted.rawsocket import WampRawSocketServerFactory transport_factory = WampRawSocketServerFactory(session_factory, serializer, debug=self.debug) else: raise Exception("should not arrive here") from autobahn.twisted.websocket import WampWebSocketClientFactory, WampWebSocketClientProtocol ## start the server from an endpoint ## from twisted.internet import reactor server = serverFromString(reactor, self.server) d = server.listen(transport_factory) def onlisten(port): print "onlisten", port config.port = port d.addCallback(onlisten) print "3" * 10 clients = [] clients_d = [] for C in client_components: ## create a WAMP application session factory ## from autobahn.twisted.wamp import ApplicationSessionFactory session_factory = ApplicationSessionFactory(config) one_done = Deferred() config.all_done.append(one_done) def make_make(Klass, done): def make(config): c = Klass(config, done) config.components.append(c) return c return make ## .. and set the session class on the factory ## session_factory.session = make_make(C, one_done) print "4" * 10 if self.transport == "websocket": from autobahn.wamp.serializer import JsonSerializer serializers = [JsonSerializer()] ## create a WAMP-over-WebSocket transport client factory ## transport_factory = WampWebSocketClientFactory( session_factory, serializers=serializers, url=self.url, debug_wamp=self.debug) print "5" * 10 if True: def maker(Klass): class TestClientProtocol(WampWebSocketClientProtocol): def onOpen(self): print "onOpen" self.txcnt = 0 self.rxcnt = 0 WampWebSocketClientProtocol.onOpen(self) def sendMessage(self, bytes, isBinary): self.txcnt += 1 print("> : {:>3} : {:<20} : {}".format( self.txcnt, Klass.__name__, bytes)) WampWebSocketClientProtocol.sendMessage( self, bytes, isBinary) def onMessage(self, bytes, isBinary): self.rxcnt += 1 print("< : {:>3} : {:<20} : {}".format( self.rxcnt, Klass.__name__, bytes)) WampWebSocketClientProtocol.onMessage( self, bytes, isBinary) return TestClientProtocol transport_factory.protocol = maker(C) else: transport_factory.protocol = WampWebSocketClientProtocol transport_factory.setProtocolOptions(failByDrop=False, openHandshakeTimeout=0, closeHandshakeTimeout=0) elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport client factory ## if self.transport == 'rawsocket-msgpack': from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() elif self.transport == 'rawsocket-json': from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() else: raise Exception("should not arrive here") from autobahn.twisted.rawsocket import WampRawSocketClientFactory transport_factory = WampRawSocketClientFactory( session_factory, serializer, debug=self.debug) ## start the client from an endpoint ## cl = clientFromString(reactor, self.client) clients_d.append(cl.connect(transport_factory)) print "6" * 10 clients.append(cl) print config.all_done config.connected_clients = None def client_connected(res): config.connected_clients = [ proto for success, proto in res if success ] print "XXXXXXX", config.connected_clients DeferredList(clients_d).addCallback(client_connected) d = DeferredList(config.all_done, consumeErrors=True) #d = config.components[1]._done print "7" def done(res): print "DOne" log.flush() log.close() if config.port: config.port.stopListening() if config.connected_clients: for proto in config.connected_clients: proto.transport.abortConnection() print("Log length: {}".format(len(config.dlog))) print(config.dlog) #from twisted.internet import reactor #reactor.callLater(1, reactor.stop) def error(err): print err d.addCallbacks(done, error) print "8", d # d2 = Deferred() return d
def startService(self): self.endpoint = endpoints.serverFromString(reactor, self.description) self.endpoint.listen(self.site)
def main(): endpoints.serverFromString(reactor, "tcp:179").listen(factory) reactor.run()
def __init__(self, reactor, top, endpoint_string): self.__top = top self.__endpoint = endpoints.serverFromString(reactor, endpoint_string) self.__port_obj = None
if enabled == "1": hostLog.log(auth, domain, "WXS to Host", "ACKNOWLE", response) else: print(loggingNotEnabledMsg) return response class Echo(protocol.Protocol): def dataReceived(self, data): printable = data.decode('ascii') print(' wrote ' + printable) response = createResponseMessage(data) print('response: ' + response.decode('ascii')) #self.transport.write(data) self.transport.write(response) class EchoFactory(protocol.Factory): def buildProtocol(self, addr): return Echo() if __name__ == "__main__": endpoints.serverFromString( reactor, "tcp:65432:interface=127.0.0.1").listen(EchoFactory()) reactor.run()
def test_stringDescription_default(self): from twisted.internet.endpoints import serverFromString with mock.patch('txi2p.sam.endpoints.getSession', fakeSession): ep = serverFromString( MemoryReactor(), "i2p:/tmp/testkeys.foo") self.assertIsInstance(ep, SAMI2PStreamServerEndpoint)
def web_server(cls, reactor, engine, description): ep = endpoints.serverFromString(reactor, description) counter = cls(engine) return ep.listen(Site(counter.app.resource()))
def _add_listen(self, description, factory): log.info("Start listened %s", description) endpoint = endpoints.serverFromString(reactor, description) new_listen = endpoint.listen(factory) self.__ports[description] = {'listen': new_listen, 'factory': factory, 'number': 1}
print('data from', self.deviceid, data) # print('data from', self.deviceid, (wtr, nut)) self.transport.write(b'\x00') elif cmd == 5: now = int(time.time() * 1000) self.transport.write(bytes([6]) + now.to_bytes(8, 'big')) elif cmd == 200: devid = int.from_bytes(data[1:5], 'big') if devid in self.devices: print('command for ', devid, data[5:]) self.devices[devid].transport.write(data[5:]) else: print('cannot find', devid) else: print('cmd', cmd) class HydroFactory(protocol.Factory): devices = {} def buildProtocol(self, addr): return HydroProtocol(self.devices) factory = HydroFactory() endpoint = endpoints.serverFromString(reactor, 'tcp:8888') endpoint.listen(factory) reactor.run()
def run(self): # A dict of protocol: {"application_instance":, "connected":, "disconnected":} dicts self.connections = {} # Make the factory self.http_factory = HTTPFactory(self) self.ws_factory = WebSocketFactory(self, server=self.server_name) protocol_options = { 'autoPingTimeout': self.ping_timeout, 'allowNullOrigin': True, 'openHandshakeTimeout': self.websocket_handshake_timeout } if self.ws_compress: def ws_accept_compression(offers): for offer in offers: if isinstance(offer, PerMessageDeflateOffer): return PerMessageDeflateOfferAccept(offer) protocol_options['perMessageCompressionAccept'] = ws_accept_compression self.ws_factory.setProtocolOptions(**protocol_options) if self.verbosity <= 1: # Redirect the Twisted log to nowhere globalLogBeginner.beginLoggingTo( [lambda _: None], redirectStandardIO=False, discardBuffer=True ) else: globalLogBeginner.beginLoggingTo([STDLibLogObserver(__name__)]) # Detect what Twisted features are enabled if http.H2_ENABLED: logger.info("HTTP/2 support enabled") else: logger.info( "HTTP/2 support not enabled (install the http2 and tls Twisted extras)" ) # Kick off the timeout loop reactor.callLater(1, self.application_checker) reactor.callLater(2, self.timeout_checker) for socket_description in self.endpoints: logger.info("Configuring endpoint %s", socket_description) ep = serverFromString(reactor, str(socket_description)) listener = ep.listen(self.http_factory) listener.addCallback(self.listen_success) listener.addErrback(self.listen_error) self.listeners.append(listener) # Set the asyncio reactor's event loop as global # TODO: Should we instead pass the global one into the reactor? asyncio.set_event_loop(reactor._asyncioEventloop) # Verbosity 3 turns on asyncio debug to find those blocking yields if self.verbosity >= 3: asyncio.get_event_loop().set_debug(True) reactor.addSystemEventTrigger("before", "shutdown", self.kill_all_applications) if not self.abort_start: # Trigger the ready flag if we had one if self.ready_callable: self.ready_callable() # Run the reactor reactor.run(installSignalHandlers=self.signal_handlers)
def main(): parser = argparse.ArgumentParser() # Network options group_network_container = parser.add_argument_group( title="Network options") group_network = group_network_container.add_mutually_exclusive_group( required=True) group_network.add_argument("--mainnet", action="store_true", default=False, help="Use MainNet") group_network.add_argument("--testnet", action="store_true", default=False, help="Use TestNet") group_network.add_argument("--privnet", action="store_true", default=False, help="Use PrivNet") group_network.add_argument("--coznet", action="store_true", default=False, help="Use CozNet") group_network.add_argument("--config", action="store", help="Use a specific config file") # Ports for RPC and REST api group_modes = parser.add_argument_group(title="Mode(s)") group_modes.add_argument( "--port-rpc", type=int, help="port to use for the json-rpc api (eg. 10332)") group_modes.add_argument("--port-rest", type=int, help="port to use for the rest api (eg. 80)") # Advanced logging setup group_logging = parser.add_argument_group(title="Logging options") group_logging.add_argument("--logfile", action="store", type=str, help="Logfile") group_logging.add_argument( "--syslog", action="store_true", help= "Log to syslog instead of to log file ('user' is the default facility)" ) group_logging.add_argument( "--syslog-local", action="store", type=int, choices=range(0, 7), metavar="[0-7]", help= "Log to a local syslog facility instead of 'user'. Value must be between 0 and 7 (e.g. 0 for 'local0')." ) group_logging.add_argument("--disable-stderr", action="store_true", help="Disable stderr logger") # Where to store stuff parser.add_argument("--datadir", action="store", help="Absolute path to use for database directories") # Now parse args = parser.parse_args() # print(args) if not args.port_rpc and not args.port_rest: print("Error: specify at least one of --port-rpc / --port-rest") parser.print_help() return if args.port_rpc == args.port_rest: print("Error: --port-rpc and --port-rest cannot be the same") parser.print_help() return if args.logfile and (args.syslog or args.syslog_local): print("Error: Cannot only use logfile or syslog at once") parser.print_help() return # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.testnet: settings.setup_testnet() elif args.privnet: settings.setup_privnet() elif args.coznet: settings.setup_coznet() if args.datadir: settings.set_data_dir(args.datadir) if args.syslog or args.syslog_local is not None: # Setup the syslog facility if args.syslog_local is not None: print("Logging to syslog local%s facility" % args.syslog_local) syslog_facility = SysLogHandler.LOG_LOCAL0 + args.syslog_local else: print("Logging to syslog user facility") syslog_facility = SysLogHandler.LOG_USER # Setup logzero to only use the syslog handler logzero.syslog(facility=syslog_facility) else: # Setup file logging if args.logfile: logfile = os.path.abspath(args.logfile) if args.disable_stderr: print("Logging to logfile: %s" % logfile) else: print("Logging to stderr and logfile: %s" % logfile) logzero.logfile(logfile, maxBytes=LOGFILE_MAX_BYTES, backupCount=LOGFILE_BACKUP_COUNT, disableStderrLogger=args.disable_stderr) else: print("Logging to stdout and stderr") # Disable logging smart contract events settings.set_log_smart_contract_events(False) # Write a PID file to easily quit the service write_pid_file() # Setup Twisted and Klein logging to use the logzero setup observer = STDLibLogObserver(name=logzero.LOGZERO_DEFAULT_LOGGER) globalLogPublisher.addObserver(observer) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) # Setup twisted reactor, NodeLeader and start the NotificationDB reactor.suggestThreadPoolSize(15) NodeLeader.Instance().Start() NotificationDB.instance().start() # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() # Default host is open for all host = "0.0.0.0" if args.port_rpc: logger.info("Starting json-rpc api server on http://%s:%s" % (host, args.port_rpc)) api_server_rpc = JsonRpcApi(args.port_rpc) endpoint_rpc = "tcp:port={0}:interface={1}".format(args.port_rpc, host) endpoints.serverFromString(reactor, endpoint_rpc).listen( Site(api_server_rpc.app.resource())) if args.port_rest: logger.info("Starting REST api server on http://%s:%s" % (host, args.port_rest)) api_server_rest = RestApi() endpoint_rest = "tcp:port={0}:interface={1}".format( args.port_rest, host) endpoints.serverFromString(reactor, endpoint_rest).listen( Site(api_server_rest.app.resource())) reactor.run() # After the reactor is stopped, gracefully shutdown the database. logger.info("Closing databases...") NotificationDB.close() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown()
def startService(self): self.endpoint = serverFromString(reactor, self.port) self.endpoint.listen(AMPFactory(self.responder))
def connectionLost(self, reason): self.server.concurrentClientCount -= 1 def dataReceived(self, data): #self - это клиент data = data.decode('utf8') print("Data received: "+data) queries = self.dataForProcessing + data; queries = queries.split("\r\n"); self.dataForProcessing = queries[-1]; del queries[-1] words = queries.split(" ") #words = query.split(" ") i = 33 answer = str(words[0]) print("Ok") self.transport.write((answer+"\r\n").encode('utf8')) print("Answer: "+answer) class Server(protocol.Factory): def __init__(self): self.concurrentClientCount = 0 def buildProtocol(self, addr): return ProcessClient(self) endpoints.serverFromString(reactor, "tcp:12345").listen(Server()) reactor.run()
def startService(self): scp = load_config(instance_config=self.instance_config) validate_config(scp) endpoint = self.endpoint if endpoint is None: if scp.has_option("Application", "endpoint"): endpoint = scp.get("Application", "endpoint") else: endpoint = "tcp:10389" factory = protocol.ServerFactory() if scp.has_option("LDAP", "proxy_cert"): proxy_cert = scp.get("LDAP", "proxy_cert") with open(proxy_cert, "r") as f: certData = f.read() cert = ssl.PrivateCertificate.loadPEM(certData) factory.options = cert.options() proxied_endpoints = [] last_proxied_scheme = None for opt in scp.options("LDAP"): if opt.startswith("proxied_endpoint"): proxied_endpoint = scp.get("LDAP", opt) proxied_endpoints.append(proxied_endpoint) if len(proxied_endpoints) == 0: log.msg("[ERROR] No proxied endpoints specified.") sys.exit(1) use_tls = scp.getboolean('LDAP', 'use_starttls') if scp.has_option('Application', 'debug'): debug_app = scp.getboolean('Application', 'debug') else: debug_app = False if scp.has_option('Application', 'debug_cache'): debug_cache = scp.getboolean('Application', 'debug_cache') else: debug_cache = False if scp.has_option('Application', 'search_cache_lifetime'): searchCacheLifetime = scp.getint('Application', 'search_cache_lifetime') else: searchCacheLifetime = 600 if scp.has_option('Application', 'search_cache_size'): searchCacheSize = scp.getint('Application', 'search_cache_size') else: searchCacheSize = 2000 if scp.has_option('Application', 'bind_cache_lifetime'): bindCacheLifetime = scp.getint('Application', 'bind_cache_lifetime') else: bindCacheLifetime = 600 if scp.has_option('Application', 'bind_cache_size'): bindCacheSize = scp.getint('Application', 'bind_cache_size') else: bindCacheSize = 2000 use_cluster = False if scp.has_section("Cluster"): cluster_endpoint = None cluster_peers = [] if not scp.has_option("Cluster", "endpoint"): log.msg("[ERROR] Section 'Cluster' does not define an 'endpoint' option.") sys.exit(1) cluster_endpoint = scp.get("Cluster", "endpoint") options = scp.options("Cluster") has_peer = False for option in options: if option.startswith("peer"): has_peer = True cluster_peers.append(scp.get("Cluster", option)) if not has_peer: log.msg("[ERROR] Section 'Cluster' does not have any 'peerxxx' options.") sys.exit(1) use_cluster = True clusterClient = LRUClusterClient(cluster_peers) clusterClient.debug = debug_cache def make_protocol(): proto = BindProxy() proto.debug = debug_app proto.use_tls = use_tls proto.clientConnector = makeClientConnector(reactor, proxied_endpoints) proto.searchResponses = {} return proto factory.protocol = make_protocol kwds = {} if use_cluster: kwds['cluster_func'] = make_cluster_func('bind', clusterClient, debug=debug_cache) factory.lastBindCache = LRUTimedCache(lifetime=bindCacheLifetime, capacity=bindCacheSize, **kwds) kwds = {} if use_cluster: kwds['cluster_func'] = make_cluster_func('search', clusterClient, debug=debug_cache) factory.searchCache = LRUTimedCache(lifetime=searchCacheLifetime, capacity=searchCacheSize, **kwds) ep = serverFromString(reactor, endpoint) d = ep.listen(factory) d.addCallback(self.set_listening_port, port_type='ldap') if use_cluster: ep = serverFromString(reactor, cluster_endpoint) cache_map = { 'bind': factory.lastBindCache, 'search': factory.searchCache,} cluster_proto_factory = LRUClusterProtocolFactory(cache_map) cluster_proto_factory.protocol.debug = debug_cache d = ep.listen(cluster_proto_factory) d.addCallback(self.set_listening_port, port_type='cluster') d.addErrback(log.err) if scp.has_section("WebService") and scp.has_option("WebService", "endpoint"): endpoint = scp.get("WebService", "endpoint") ws_site = make_ws(bindCache=factory.lastBindCache, portal=self.portal) ws_site.displayTracebacks = debug_cache ep = serverFromString(reactor, endpoint) d = ep.listen(ws_site) d.addCallback(self.set_listening_port, port_type='ws')