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)
