def makeService(config): """ Configure a service for operating a mail server. The returned service may include POP3 servers, SMTP servers, or both, depending on the configuration passed in. If there are multiple servers, they will share all of their non-network state (i.e. the same user accounts are available on all of them). @type config: L{Options <usage.Options>} @param config: Configuration options specifying which servers to include in the returned service and where they should keep mail data. @rtype: L{IService <twisted.application.service.IService>} provider @return: A service which contains the requested mail servers. """ if config['esmtp']: rmType = relaymanager.SmartHostESMTPRelayingManager smtpFactory = config.service.getESMTPFactory else: rmType = relaymanager.SmartHostSMTPRelayingManager smtpFactory = config.service.getSMTPFactory if config['relay']: dir = config['relay'] if not os.path.isdir(dir): os.mkdir(dir) config.service.setQueue(relaymanager.Queue(dir)) default = relay.DomainQueuer(config.service) manager = rmType(config.service.queue) if config['esmtp']: manager.fArgs += (None, None) manager.fArgs += (config['hostname'], ) helper = relaymanager.RelayStateHelper(manager, 1) helper.setServiceParent(config.service) config.service.domains.setDefaultDomain(default) if config['pop3']: f = config.service.getPOP3Factory() for endpoint in config['pop3']: svc = internet.StreamServerEndpointService(endpoint, f) svc.setServiceParent(config.service) if config['smtp']: f = smtpFactory() if config['hostname']: f.domain = config['hostname'] f.fArgs = (f.domain, ) if config['esmtp']: f.fArgs = (None, None) + f.fArgs for endpoint in config['smtp']: svc = internet.StreamServerEndpointService(endpoint, f) svc.setServiceParent(config.service) return config.service
def _setup_relay(self, error, advertise_version=None): self.sp = service.MultiService() self.sp.startService() # need to talk to twisted team about only using unicode in # endpoints.serverFromString db = create_channel_db(":memory:") self._usage_db = create_usage_db(":memory:") self._rendezvous = make_server(db, advertise_version=advertise_version, signal_error=error, usage_db=self._usage_db) ep = endpoints.TCP4ServerEndpoint(reactor, 0, interface="127.0.0.1") site = make_web_server(self._rendezvous, log_requests=False) # self._lp = yield ep.listen(site) s = MyInternetService(ep, site) s.setServiceParent(self.sp) self.rdv_ws_port = yield s.getPort() self._relay_server = s # self._rendezvous = s._rendezvous self.relayurl = u"ws://127.0.0.1:%d/v1" % self.rdv_ws_port # ws://127.0.0.1:%d/wormhole-relay/ws self.transitport = allocate_tcp_port() ep = endpoints.serverFromString( reactor, "tcp:%d:interface=127.0.0.1" % self.transitport) self._transit_server = f = Transit(blur_usage=None, log_file=None, usage_db=None) internet.StreamServerEndpointService(ep, f).setServiceParent(self.sp) self.transit = u"tcp:127.0.0.1:%d" % self.transitport
def create_endpoint_services(reactor, parent, listen_endpoints, factory): for listen_endpoint in listen_endpoints: endpoint = endpoints.serverFromString(reactor, listen_endpoint.encode('utf-8')) service = internet.StreamServerEndpointService(endpoint, factory) # FIXME: Use addService on parent ? service.setServiceParent(parent)
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 addBouncer(torControlProtocol): data_dir = os.path.join(torconfig.DataDirectory, 'bouncer') bouncer_service = internet.StreamServerEndpointService( getHSEndpoint(data_dir), ooniBouncer) bouncer_service.setName('bouncer') multiService.addService(bouncer_service) bouncer_service.startService() return bouncer_service
def addCollector(torControlProtocol): data_dir = os.path.join(torconfig.DataDirectory, 'collector') collector_service = internet.StreamServerEndpointService( getHSEndpoint(data_dir), ooniBackend) collector_service.setName('collector') multiService.addService(collector_service) collector_service.startService() return collector_service
def makeService(self, options): factory = ProxyFactory(options["proxy-to"]) serviceContainer = MultiService() for bind in options["bind"]: endpoint = serverFromString(reactor, bind) service = internet.StreamServerEndpointService(endpoint, factory) service.setServiceParent(serviceContainer) return serviceContainer
def makeService(opt): outline = Outline(filepath.FilePath(opt['store'])) resource = makeWrapper(outline.app.resource(), opt['username'], opt['password']) site = server.Site(resource) port = endpoints.TCP4ServerEndpoint(reactor, opt['port'], interface=opt['interface']) webService = internet.StreamServerEndpointService(endpoint=port, factory=site) return webService
def makeService(config): root = resource.Resource() site = server.Site(root) root.putChild(b"", static.Data(b"SPAKE2 interop server", "text/plain")) root.putChild(b"0.3", ABS("ve-p03/bin/spake2_interop_python_0_3")) root.putChild(b"0.7", ABS("ve-p07/bin/spake2_interop_python_0_7")) ep = endpoints.serverFromString(reactor, config["port"]) s = internet.StreamServerEndpointService(ep, site) return s
def makeService(opt): from twisted.internet import reactor ops_instance = operations.Operations(reactor) resource = ops_instance.app.resource() site = server.Site(resource) ret = taservice.MultiService() for port in opt.ports: ep = endpoints.serverFromString(reactor, port) serv = internet.StreamServerEndpointService(ep, site) serv.setServiceParent(ret) return ret
def makeService(self, options): """ Construct a TCPServer from a factory defined in myproject. """ if hasattr(options, "subOptions"): # if the "server" subcommand of the "gopher" command doesn't have # any parameters passed, then subOptions won't be defined, in which # case we'll need to fall back to the default self.port = options.subOptions["port"] factory = server.GopherServerFactory() return internet.StreamServerEndpointService(self.getEndpoint(), factory)
def createService(endpoint, role, endpoint_config): if role == 'bouncer': factory = OONIBouncer() elif role == 'collector': factory = OONICollector() elif role == 'web_connectivity': factory = http_helpers.WebConnectivityHelper else: raise Exception("unknown service type") service = internet.StreamServerEndpointService(endpoint, factory) service.setName("-".join([endpoint_config['type'], role])) return service
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 makeService(self, options): """ Called by Twisted after having parsed the command-line options. :param options: ``usage.Options`` instance :return: the server instance """ # Configuration is mandatory if options['config'] is None: print('You need to specify a configuration file via `twistd ldap-proxy -c config.ini`.') sys.exit(1) config = load_config(options['config']) factory = ProxyServerFactory(config) endpoint_string = serverFromString(reactor, config['ldap-proxy']['endpoint']) return internet.StreamServerEndpointService(endpoint_string, factory)
def makeService(self, options): """Construct a server using MLLPFactory. :rtype: :py:class:`twisted.application.internet.StreamServerEndpointService` """ from twisted.internet import reactor from txHL7.mllp import IHL7Receiver, MLLPFactory receiver_name = options['receiver'] receiver_class = reflect.namedClass(receiver_name) verifyClass(IHL7Receiver, receiver_class) factory = MLLPFactory(receiver_class()) endpoint = endpoints.serverFromString(reactor, options['endpoint']) server = internet.StreamServerEndpointService(endpoint, factory) server.setName(u"mllp-{0}".format(receiver_name)) return server
def __init__(self, reactor, descriptions, factory): service.MultiService.__init__(self) self._descriptions = descriptions self._factory = factory self._listeners = [] def recordListener(listener): self._listeners.append(listener) return listener for description in self._descriptions: endpoint = _NotifyListenEndpointWrapper( serverFromString(reactor, description)) endpoint.notifyListen().addCallback(recordListener) internet.StreamServerEndpointService( endpoint, factory).setServiceParent(self)
def makeService(options): """ Generate and return a definition for all the services that this package needs to run. Will return a 'MultiService' object with two children. One is a ExampleFactory listening on the configured endpoint, and the other is an example custom Service that will do some set-up. """ from twisted.internet import reactor debug = options['debug'] f = ExampleFactory(debug=debug) endpoint = endpoints.serverFromString(reactor, options['endpoint']) server_service = internet.StreamServerEndpointService(endpoint, f) server_service.setName('Example Server') return server_service
def make_plugin(config): http_config = HttpConfig(config) root = resource.Resource() harold = resource.Resource() root.putChild('harold', harold) site = server.Site(root) site.displayTracebacks = False endpoint = serverFromString(reactor, http_config.endpoint) service = internet.StreamServerEndpointService(endpoint, site) plugin = Plugin() plugin.root = harold plugin.hmac_secret = http_config.hmac_secret plugin.add_service(service) return plugin
def make_plugin(application, app_config): http_config = config.parse_config(app_config, { "endpoint": config.String, "hmac_secret": config.String, }) root = resource.Resource() harold = resource.Resource() root.putChild('harold', harold) site = server.Site(root) site.noisy = False site.displayTracebacks = False endpoint = serverFromString(reactor, http_config.endpoint) service = internet.StreamServerEndpointService(endpoint, site) service.setServiceParent(application) return HttpPlugin(harold, http_config.hmac_secret)
def makeService(config): # finger on port 79 s = service.MultiService() f = FingerService(config["file"]) h = strports.service("tcp:1079", IFingerFactory(f)) h.setServiceParent(s) # website on port 8000 r = resource.IResource(f) r.templateDirectory = config["templates"] site = server.Site(r) j = strports.service("tcp:8000", site) j.setServiceParent(s) # ssl on port 443 # if config.get('ssl'): # k = strports.service( # "ssl:port=443:certKey=cert.pem:privateKey=key.pem", site # ) # k.setServiceParent(s) # irc fingerbot if "ircnick" in config: i = IIRCClientFactory(f) i.nickname = config["ircnick"] ircserver = config["ircserver"] b = internet.ClientService( endpoints.HostnameEndpoint(reactor, ircserver, 6667), i) b.setServiceParent(s) # Pespective Broker on port 8889 if "pbport" in config: m = internet.StreamServerEndpointService( endpoints.TCP4ServerEndpoint(reactor, int(config["pbport"])), pb.PBServerFactory(IPerspectiveFinger(f)), ) m.setServiceParent(s) return s
def makeService(self, options): """Construct a server using MLLPFactory. :rtype: :py:class:`twisted.application.internet.StreamServerEndpointService` """ from twisted.internet import reactor from txHL7.mllp import IHL7Receiver, MLLPFactory receiver_name = options['receiver'] receiver_class = reflect.namedClass(receiver_name) verifyClass(IHL7Receiver, receiver_class) factory = MLLPFactory(receiver_class()) multi_service = MultiService() for port_number in PORTS: port = "tcp:interface={0}:port={1}".format( HOST, port_number, ) endpoint = endpoints.serverFromString(reactor, port) server = internet.StreamServerEndpointService(endpoint, factory) server.setName(u"mllp-{0}-{1}".format(receiver_name, port_number)) multi_service.addService(server) return multi_service
def _setup_relay(self, error, advertise_version=None): self.sp = service.MultiService() self.sp.startService() self.relayport = allocate_tcp_port() # need to talk to twisted team about only using unicode in # endpoints.serverFromString s = RelayServer("tcp:%d:interface=127.0.0.1" % self.relayport, advertise_version=advertise_version, signal_error=error) s.setServiceParent(self.sp) self._relay_server = s self._rendezvous = s._rendezvous self.relayurl = u"ws://127.0.0.1:%d/v1" % self.relayport self.rdv_ws_port = self.relayport # ws://127.0.0.1:%d/wormhole-relay/ws self.transitport = allocate_tcp_port() ep = endpoints.serverFromString(reactor, "tcp:%d:interface=127.0.0.1" % self.transitport) self._transit_server = f = Transit(blur_usage=None, log_file=None, usage_db=None) internet.StreamServerEndpointService(ep, f).setServiceParent(self.sp) self.transit = u"tcp:127.0.0.1:%d" % self.transitport
def __init__(self, rendezvous_web_port, advertise_version, db_url=":memory:", blur_usage=None, signal_error=None, stats_file=None, allow_list=True, websocket_protocol_options=()): service.MultiService.__init__(self) self._blur_usage = blur_usage self._allow_list = allow_list self._db_url = db_url db = get_db(db_url) welcome = { # 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: # 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. 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) _set_options(websocket_protocol_options, wsrf) 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) 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
def build_server(app, factory, endpoint, name=None): logger.debug("serve %s on %s", factory, endpoint) ept = endpoints.serverFromString(reactor, endpoint) ss = internet.StreamServerEndpointService(ept, factory) return attach_service(app, ss, name)
def makeService(options): from twisted.internet import reactor # rules/game engine from mock import MagicMock rules = MagicMock() rules.workRequirement.return_value = None rules.energyRequirement.return_value = 0 rules.isAllowed.return_value = None engine = XatroEngine(rules) # web web_app = GameObserver(FilePath(options['web-static-path'])) site = Site(web_app.app.resource()) endpoint = endpoints.serverFromString(reactor, options['web-endpoint']) web_service = internet.StreamServerEndpointService(endpoint, site) web_service.setName('Web Observer Service') # passwords auth = FileStoredPasswords(options['password-file']) # world world = World(web_app.eventReceived, engine, auth) # make the board makeBoard(world, options) # AMP f = amp.AvatarFactory(world) endpoint = endpoints.serverFromString(reactor, options['amp-proto-endpoint']) amp_service = internet.StreamServerEndpointService(endpoint, f) amp_service.setName('AMP Bot Service') # line protocol f = BotFactory(world, { 'move': action.Move, 'charge': action.Charge, 'consume': action.ConsumeEnergy, 'share': action.ShareEnergy, 'look': action.Look, 'shoot': action.Shoot, 'repair': action.Repair, 'tool': action.MakeTool, 'openportal': action.OpenPortal, 'useportal': action.UsePortal, 'squares': action.ListSquares, 'createteam': action.CreateTeam, 'jointeam': action.JoinTeam, }) endpoint = endpoints.serverFromString(reactor, options['line-proto-endpoint']) line_service = internet.StreamServerEndpointService(endpoint, f) line_service.setName('Line-protocol Bot Service') ms = service.MultiService() line_service.setServiceParent(ms) web_service.setServiceParent(ms) amp_service.setServiceParent(ms) return ms
self.keepalive.start(30) def onMessage(self, payload, isBinary): self.keepalive.reset() if isBinary: self.other.transport.write(payload) def onPong(self, payload): self.keepalive.reset() def onClose(self, wasClean, code, reason): log.msg("closed connection from " + self.peer) try: self.keepalive.stop() except: pass try: self.other.transport.signalProcess(signal.SIGHUP) except: pass if __name__ == "__builtin__": from twisted.application import service, internet from twisted.internet import endpoints application = service.Application("wstty") internet.StreamServerEndpointService( endpoints.serverFromString(reactor, ENDPOINT), websocket.WebSocketServerFactory.forProtocol(WSTTYProtocol) ).setServiceParent(application)