def startService(self): self._client_factory = CarbonClientFactory() self._tcp_client = TCPClient(self._hostname, self._port, self._client_factory, reactor=self._reactor) self._tcp_client.setServiceParent(self) for repeating_metric_handle in self._repeating_metric_handles: repeating_metric_handle.start() service.MultiService.startService(self)
def start(self): """interface requirement""" if self.running(): return self.factory = XMPPClientFactory( self.jid, decrypt(self.SERVICECONFIG.JABBER_PASSWORD)) self.factory.addBootstrap(STREAM_CONNECTED_EVENT, self.connectionMade) self.factory.addBootstrap(STREAM_END_EVENT, self.connectionLost) self.factory.addBootstrap(STREAM_AUTHD_EVENT, self.connectionAuthenticated) self.factory.addBootstrap(STREAM_ERROR_EVENT, self.receivedError) self.factory.addBootstrap(INIT_FAILED_EVENT, self.initFailed) self.service = TCPClient(self.SERVICECONFIG.JABBER_SERVER, self.SERVICECONFIG.JABBER_PORT, self.factory) self.service.setServiceParent(self.parentService) #build/rebuild jabber teams if not os.path.exists(self.SERVICECONFIG.JABBER_TEAM_ROSTER): try: os.makedirs(self.SERVICECONFIG.JABBER_TEAM_ROSTER) except: log('Cannot load team rosters because %s does not exits' % \ self.SERVICECONFIG.JABBER_TEAM_ROSTER) return for name in os.listdir(self.SERVICECONFIG.JABBER_TEAM_ROSTER): f = (self.SERVICECONFIG.JABBER_TEAM_ROSTER, name) if os.path.isfile('%s/%s' % f): Team(name) #preload team rosters
def __init__(self, amqp_url=None, publish_confirms=True): """Initialize the service.""" service.MultiService.__init__(self) self._parameters = pika.URLParameters(amqp_url or config.conf["amqp_url"]) self._confirms = publish_confirms if amqp_url.startswith("amqps"): _configure_tls_parameters(self._parameters) if self._parameters.client_properties is None: self._parameters.client_properties = config.conf[ "client_properties"] factory = FedoraMessagingFactoryV2(self._parameters, self._confirms) if self._parameters.ssl_options: self._service = SSLClient( host=self._parameters.host, port=self._parameters.port, factory=factory, contextFactory=_ssl_context_factory(self._parameters), ) else: self._service = TCPClient(host=self._parameters.host, port=self._parameters.port, factory=factory) self._service.factory = factory name = "{}{}:{}".format( "ssl:" if self._parameters.ssl_options else "", self._parameters.host, self._parameters.port, ) self._service.setName(name) self._service.setServiceParent(self)
def create_service(self, consumer): conf = consumer.app.conf local_ivo = get_local_ivo(consumer.app) host, port = get_host_port(conf['voevent_receiver_address']) self._factory = factory = VOEventSubscriberFactory( local_ivo=local_ivo, handlers=[Handler()]) return TCPClient(host, port, factory)
def configure_services(self, configuration): read_configuration() for section in configuration.sections(): if section.startswith("world "): factory = BravoFactory(section[6:]) server = TCPServer(factory.port, factory, interface=factory.interface) server.setName(factory.name) self.addService(server) elif section.startswith("irc "): try: from bravo.irc import BravoIRC except ImportError: log.msg("Couldn't import IRC stuff!") else: factory = BravoIRC(self.namedServices, section[4:]) client = TCPClient(factory.host, factory.port, factory) client.setName(factory.name) self.addService() elif section.startswith("infiniproxy "): factory = BetaProxyFactory(section[12:]) server = TCPServer(factory.port, factory) server.setName(factory.name) self.addService(server) elif section.startswith("infininode "): factory = InfiniNodeFactory(section[11:]) server = TCPServer(factory.port, factory) server.setName(factory.name) self.addService(server)
def setupService(self): """ Setup the application component. """ is_secure, host, port, resource, path, params = parse_ws_url(self.url) # factory for use ApplicationSession def create(): cfg = ComponentConfig(self.realm, self.extra) session = self.make(cfg) return session # create a WAMP-over-WebSocket transport client factory transport_factory = self.factory(create, url=self.url) # setup the client from a Twisted endpoint if is_secure: from twisted.application.internet import SSLClient ctx = self.context_factory if ctx is None: from twisted.internet.ssl import optionsForClientTLS ctx = optionsForClientTLS(host) client = SSLClient(host, port, transport_factory, contextFactory=ctx) else: if self.context_factory is not None: raise Exception("context_factory specified on non-secure URI") from twisted.application.internet import TCPClient client = TCPClient(host, port, transport_factory) client.setServiceParent(self)
def setup(self, cfg): BasePlugin.setup(self, cfg) self.factory = AmqpFactory(plugin=self) self.factory.read("*", self.amqp_receive) self.client = TCPClient(self.cfg.get("host", "localhost"), self.cfg.get("port", 5672), self.factory)
def __init__(self, port: int, factory: MasterClientProtocolFactory, interface: str = '', domains: List[str] = []) -> None: service.MultiService.__init__(self) self._protocol_factory = factory self._domains = domains self._child_service = TCPClient(interface, port, factory) self._child_service.setServiceParent(self)
def __init__(self, port, factory, interface='', domains=[]): service.MultiService.__init__(self) self._protocol_factory = factory self._domains = domains self._child_service = TCPClient(interface, port, factory) self._child_service.setServiceParent(self)
def startConnection(self): """Attempt to start the node and connect to LabRAD.""" print 'Connecting to %s:%d...' % (self.host, self.port) node = NodeServer(self.name, self.host, self.port) node.onStartup().addErrback(self._error) node.onShutdown().addCallbacks(self._disconnected, self._error) self.cxn = TCPClient(self.host, self.port, node) self.addService(self.cxn)
def setup(self, cfg): BasePlugin.setup(self, cfg) self.factory = MpdFactory(plugin=self) self.factory.plugin = self self.client = TCPClient(self.cfg.get("host", "localhost"), self.cfg.get("port", 6600), self.factory)
def setup(self, cfg): BasePlugin.setup(self, cfg) self.factory = TivoFactory(plugin=self) self.factory.plugin = self self.client = TCPClient(self.cfg.get("host", "mytivo"), self.cfg.get("port", 31339), self.factory) self.cache = dict()
def setupReceivers(root_service, settings): from carbon.protocols import MetricLineReceiver, MetricPickleReceiver, MetricDatagramReceiver for protocol, interface, port in [ (MetricLineReceiver, settings.LINE_RECEIVER_INTERFACE, settings.LINE_RECEIVER_PORT), (MetricPickleReceiver, settings.PICKLE_RECEIVER_INTERFACE, settings.PICKLE_RECEIVER_PORT) ]: if port: factory = ServerFactory() factory.protocol = protocol service = TCPServer(port, factory, interface=interface) service.setServiceParent(root_service) if settings.ENABLE_UDP_LISTENER: service = UDPServer(int(settings.UDP_RECEIVER_PORT), MetricDatagramReceiver(), interface=settings.UDP_RECEIVER_INTERFACE) service.setServiceParent(root_service) if settings.ENABLE_AMQP: from carbon import amqp_listener amqp_host = settings.AMQP_HOST amqp_port = settings.AMQP_PORT amqp_user = settings.AMQP_USER amqp_password = settings.AMQP_PASSWORD amqp_verbose = settings.AMQP_VERBOSE amqp_vhost = settings.AMQP_VHOST amqp_spec = settings.AMQP_SPEC amqp_exchange_name = settings.AMQP_EXCHANGE factory = amqp_listener.createAMQPListener( amqp_user, amqp_password, vhost=amqp_vhost, spec=amqp_spec, exchange_name=amqp_exchange_name, verbose=amqp_verbose) service = TCPClient(amqp_host, amqp_port, factory) service.setServiceParent(root_service) if settings.ENABLE_MANHOLE: from carbon import manhole factory = manhole.createManholeListener() service = TCPServer(settings.MANHOLE_PORT, factory, interface=settings.MANHOLE_INTERFACE) service.setServiceParent(root_service)
def makeService(self, options): """Construct a service.""" services = MultiService() config_file = options["config-file"] config = Config.load(config_file) log_service = LogService(config["logfile"]) log_service.setServiceParent(services) oops_config = config["oops"] oops_dir = oops_config["directory"] oops_reporter = oops_config["reporter"] oops_service = OOPSService(log_service, oops_dir, oops_reporter) oops_service.setServiceParent(services) frontend_config = config["frontend"] frontend_port = frontend_config["port"] frontend_prefix = frontend_config["prefix"] frontend_interface = frontend_config["interface"] frontend_manager = DeprecatedQueueManager(frontend_prefix) broker_config = config["broker"] broker_port = broker_config["port"] broker_host = broker_config["host"] broker_username = broker_config["username"] broker_password = broker_config["password"] broker_vhost = broker_config["vhost"] cb_connected = frontend_manager.connected cb_disconnected = frontend_manager.disconnected cb_failed = lambda connector_and_reason: (log.err( connector_and_reason[1], "Connection failed")) client_factory = AMQFactory(broker_username, broker_password, broker_vhost, cb_connected, cb_disconnected, cb_failed) client_service = TCPClient(broker_host, broker_port, client_factory) client_service.setName("amqp") client_service.setServiceParent(services) frontend_resource = FrontEndAjax(frontend_manager) frontend_service = TCPServer(frontend_port, Site(frontend_resource), interface=frontend_interface) frontend_service.setName("frontend") frontend_service.setServiceParent(services) return services
def configure_services(self): for section in self.config.sections(): if section.startswith("world "): # Bravo worlds. Grab a list of endpoints and load them. factory = BravoFactory(self.config, section[6:]) interfaces = self.config.getlist(section, "interfaces") for service in services_for_endpoints(interfaces, factory): self.addService(service) self.factorylist.append(factory) elif section == "web": try: from bravo.web import bravo_site except ImportError: log.msg("Couldn't import web stuff!") else: factory = bravo_site(self.namedServices) factory.name = "web" interfaces = self.config.getlist("web", "interfaces") for service in services_for_endpoints(interfaces, factory): self.addService(service) elif section.startswith("irc "): try: from bravo.irc import BravoIRC except ImportError: log.msg("Couldn't import IRC stuff!") else: self.irc = True self.ircbots.append(section) elif section.startswith("infiniproxy "): factory = BetaProxyFactory(self.config, section[12:]) interfaces = self.config.getlist(section, "interfaces") for service in services_for_endpoints(interfaces, factory): self.addService(service) elif section.startswith("infininode "): factory = InfiniNodeFactory(self.config, section[11:]) interfaces = self.config.getlist(section, "interfaces") for service in services_for_endpoints(interfaces, factory): self.addService(service) if self.irc: for section in self.ircbots: factory = BravoIRC(self.factorylist, self.config, section[4:]) client = TCPClient(factory.host, factory.port, factory) client.setName(factory.config) self.addService(client)
def _makeBroker(self, broker_config): """Create the messaging broker.""" broker_port = broker_config["port"] broker_host = broker_config["host"] broker_username = broker_config["username"] broker_password = broker_config["password"] broker_vhost = broker_config["vhost"] cb_connected = lambda ignored: None # TODO cb_disconnected = lambda ignored: None # TODO cb_failed = lambda connector_and_reason: (log.err( connector_and_reason[1], "Connection failed")) client_factory = AMQFactory(broker_username, broker_password, broker_vhost, cb_connected, cb_disconnected, cb_failed) client_service = TCPClient(broker_host, broker_port, client_factory) client_service.setName("amqp") return client_service
def configure_services(self, configuration): read_configuration() for section in configuration.sections(): if section.startswith("world "): factory = BravoFactory(section[6:]) server = TCPServer(factory.port, factory, interface=factory.interface) self.addService(server) elif section.startswith("irc "): factory = BravoIRC(worlds, section[4:]) self.addService(TCPClient(factory.host, factory.port, factory)) elif section.startswith("infiniproxy "): factory = BetaProxyFactory(section[12:]) self.addService(TCPServer(factory.port, factory)) elif section.startswith("infininode "): factory = InfiniNodeFactory(section[11:]) self.addService(TCPServer(factory.port, factory))
def create_service(self, consumer): from comet.icomet import IHandler from twisted.application.internet import TCPClient from zope.interface import implementer from .subscriber import VOEventSubscriberFactory @implementer(IHandler) class Handler: def __call__(self, event): from twisted.internet import reactor reactor.callInThread(voevent_received.send, sender=None, xml_document=event) conf = consumer.app.conf local_ivo = get_local_ivo(consumer.app) host, port = get_host_port(conf['voevent_receiver_address']) self._factory = factory = VOEventSubscriberFactory( local_ivo=local_ivo, handlers=[Handler()]) return TCPClient(host, port, factory)
def start(self, dv): """Start the given DataVaultMultihead server. The server startup and shutdown logic changed in pylabrad 0.95, so we need separate logic to handle the old and new cases. Args: dv (DataVaultMultihead): The labrad server object that we want to start. Returns: A deferred that fires after the server has successfully started. This deferred contains a function that can be invoked to shutdown the server. That function itself returns a deferred that will fire when the shutdown is complete. """ if hasattr(dv, 'startup'): # pylabrad 0.95+ p = yield protocol.connect(self.host, self.port) yield p.authenticate(password=self.password) yield dv.startup(p) @inlineCallbacks def stop_func(): dv.disconnect() yield dv.onShutdown() else: # pylabrad 0.94 and earlier try: dv.configure_tls(self.host, "starttls") except AttributeError: self.report("pylabrad doesn't support TLS") cxn = TCPClient(self.host, self.port, dv) cxn.startService() yield dv.onStartup() @inlineCallbacks def stop_func(): yield cxn.stopService() returnValue(stop_func)
def connect(self): factory = self.factoryClass(self._parameters, self._bindings) if self._parameters.ssl_options: serv = SSLClient( host=self._parameters.host, port=self._parameters.port, factory=factory, contextFactory=_ssl_context_factory(self._parameters), ) else: serv = TCPClient( host=self._parameters.host, port=self._parameters.port, factory=factory ) serv.factory = factory name = "{}{}:{}".format( "ssl:" if self._parameters.ssl_options else "", self._parameters.host, self._parameters.port, ) serv.setName(name) serv.setServiceParent(self)
def build(cls, root_service): if not settings.ENABLE_AMQP: return amqp_host = settings.AMQP_HOST amqp_port = settings.AMQP_PORT amqp_user = settings.AMQP_USER amqp_password = settings.AMQP_PASSWORD amqp_verbose = settings.AMQP_VERBOSE amqp_vhost = settings.AMQP_VHOST amqp_spec = settings.AMQP_SPEC amqp_exchange_name = settings.AMQP_EXCHANGE factory = createAMQPListener(amqp_user, amqp_password, vhost=amqp_vhost, spec=amqp_spec, exchange_name=amqp_exchange_name, verbose=amqp_verbose) service = TCPClient(amqp_host, amqp_port, factory) service.setServiceParent(root_service)
def connect(self): factory = self.factoryClass(self._parameters, self._bindings) if self._parameters.ssl_options: serv = SSLClient( host=self._parameters.host, port=self._parameters.port, factory=factory, contextFactory=ssl.ClientContextFactory(), ) else: serv = TCPClient( host=self._parameters.host, port=self._parameters.port, factory=factory, ) serv.factory = factory name = '{}{}:{}'.format( 'ssl:' if self._parameters.ssl_options else '', self._parameters.host, self._parameters.port, ) serv.setName(name) serv.setServiceParent(self)
def startService(self): self._tcp_client = TCPClient(self._interface, self._port, factory=self._protocol_factory) self._tcp_client.setServiceParent(self) return service.MultiService.startService(self)
def createBaseService(config): from carbon.conf import settings from carbon.protocols import (MetricLineReceiver, MetricPickleReceiver, MetricDatagramReceiver) root_service = CarbonRootService() root_service.setName(settings.program) use_amqp = settings.get("ENABLE_AMQP", False) if use_amqp: from carbon import amqp_listener amqp_host = settings.get("AMQP_HOST", "localhost") amqp_port = settings.get("AMQP_PORT", 5672) amqp_user = settings.get("AMQP_USER", "guest") amqp_password = settings.get("AMQP_PASSWORD", "guest") amqp_verbose = settings.get("AMQP_VERBOSE", False) amqp_vhost = settings.get("AMQP_VHOST", "/") amqp_spec = settings.get("AMQP_SPEC", None) amqp_exchange_name = settings.get("AMQP_EXCHANGE", "graphite") for interface, port, backlog, protocol in ( (settings.LINE_RECEIVER_INTERFACE, settings.LINE_RECEIVER_PORT, settings.LINE_RECEIVER_BACKLOG, MetricLineReceiver), (settings.PICKLE_RECEIVER_INTERFACE, settings.PICKLE_RECEIVER_PORT, settings.PICKLE_RECEIVER_BACKLOG, MetricPickleReceiver)): if port: factory = ServerFactory() factory.protocol = protocol service = TCPServer(int(port), factory, interface=interface, backlog=backlog) service.setServiceParent(root_service) if settings.ENABLE_UDP_LISTENER: service = UDPServer(int(settings.UDP_RECEIVER_PORT), MetricDatagramReceiver(), interface=settings.UDP_RECEIVER_INTERFACE) service.setServiceParent(root_service) if use_amqp: factory = amqp_listener.createAMQPListener( amqp_user, amqp_password, vhost=amqp_vhost, spec=amqp_spec, exchange_name=amqp_exchange_name, verbose=amqp_verbose) service = TCPClient(amqp_host, int(amqp_port), factory) service.setServiceParent(root_service) if settings.ENABLE_MANHOLE: from carbon import manhole factory = manhole.createManholeListener() service = TCPServer(int(settings.MANHOLE_PORT), factory, interface=settings.MANHOLE_INTERFACE) service.setServiceParent(root_service) if settings.USE_WHITELIST: from carbon.regexlist import WhiteList, BlackList WhiteList.read_from(settings["whitelist"]) BlackList.read_from(settings["blacklist"]) # Instantiate an instrumentation service that will record metrics about # this service. from carbon.instrumentation import InstrumentationService service = InstrumentationService() service.setServiceParent(root_service) return root_service
def _connect(self): "Connect to the worker" masterClient = TCPClient(self._workerHost, self._workerPort, self._clientFactory) masterClient.setServiceParent(self) log.msg("TaskMaster connects to Worker")
def loadSubscriptionService(self): subscriberService = TCPClient(self.pubsub_config['host'], int(self.pubsub_config['port']), ScrapyRedisSubscriberFactory(self)) subscriberService.setServiceParent(self.app)
color_f_navy + shorten("https://code.google.com/p/dolphin-emu/source/detail?r=" + revision["revision"]) + color_normal, msg) self.bot_factory.bot.commit_msg(txt.encode('utf-8')) if len(payload["revisions"]) > 5: msg = u"... and %d more commits (not displayed)" % ( len(payload["revisions"]) - 5) self.bot_factory.bot.commit_msg(msg.encode("utf-8")) return '' ''' All config can be done here (except for bot nick...) TODO more rubust config... ''' # The application for twistd application = Application("gcode-irc-bot") # Setup IRC bot PROJECT_NAME = 'dolphin-dev' botf = CHookBotFactory('#' + PROJECT_NAME) # Setup HTTP listener root = Resource() root.putChild('dolphin-emu', PostPage(botf, open('gcode-password.txt').read().strip())) # Start! TCPServer(8800, Site(root)).setServiceParent(application) TCPClient("irc.freenode.net", 6667, botf).setServiceParent(application)
def loadClientService(self): clientService = TCPClient(self.pubsub_config['host'], int(self.pubsub_config['port']), ScrapyRedisClientFactory(self)) clientService.setServiceParent(self.app)
def _connect(self): "Connect to the taskmaster" workerClient = TCPClient(self._masterHost, self._masterPort, self._worker) workerClient.setServiceParent(self) log.msg("Worker connects to TaskMaster")
def _connect(self, worker, timeout, bindAddress): service = TCPClient(self.options['hostname'], self.options['port'], AmqpFactory(worker), timeout, bindAddress) service.setServiceParent(worker)