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 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
class VanillaMasterClientService(service.MultiService):
implementer(IAuthService)
@staticmethod
def build(punitive_model: PunitiveModel, host: str, port: int, register_port: int):
domains = ["localhost", ""]
punitive_model_adapter = PunitiveModelAdapter(punitive_model)
protocol_factory = MasterClientProtocolFactory(punitive_model_adapter, host, register_port)
return VanillaMasterClientService(port, protocol_factory, interface=host, domains=domains)
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 handles_domain(self, auth_domain):
return auth_domain in self._domains
def try_authenticate(self, auth_domain, auth_name):
return self._protocol_factory.try_auth(auth_domain, auth_name)
def answer_challenge(self, auth_domain, auth_id, answer):
return self._protocol_factory.answer_challenge(auth_id, answer)
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)
class MaestroMasterClientService(service.MultiService):
implements(IAuthService)
@staticmethod
def build(punitive_model, config):
host = config.get('host')
port = config.get('port')
register_port = config.get('register_port')
domains = config.get('domains')
punitive_model_adapter = PunitiveModelAdapter(punitive_model)
protocol_factory = MaestroProtocolFactory(punitive_model_adapter, host, register_port)
return MaestroMasterClientService(port, protocol_factory, interface=host, domains=domains)
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 handles_domain(self, auth_domain):
return auth_domain in self._domains
def try_authenticate(self, auth_domain, auth_name):
return self._protocol_factory.try_auth(auth_domain, auth_name)
def answer_challenge(self, auth_domain, auth_id, answer):
return self._protocol_factory.answer_challenge(auth_id, answer)
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)
class MessageSender(MultiService):
'''Keeps track of the amqp connection and can send messages. Raises an
exception if a message is sent when there is no amqp connection'''
def __init__(self, specfile, amqp_config):
super(MessageSender, self).__init__()
self.amqp_config = amqp_config
self.factory = AmqpFactory(
specfile, amqp_config, self._connected_callback,
self._disconnected_callback)
def startService(self):
super(MessageSender, self).startService()
self.amqp_service = TCPClient(
self.amqp_config['hostname'], self.amqp_config['port'],
self.factory)
self.amqp_service.setServiceParent(self)
def _connected_callback(self, client):
self.client = client
def _disconnected_callback(self):
self.client = None
def send_message(self, message, **kwargs):
if not hasattr(self, 'client') or self.client is None:
raise AmqpConnectionError(
'Message not sent, AMQP connection error.')
return self.client.publish_message(message, **kwargs)
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 __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)
class FedoraMessagingServiceV2(service.MultiService):
"""
A Twisted service to connect to the Fedora Messaging broker.
Args:
amqp_url (str): URL to use for the AMQP server.
publish_confirms (bool): If true, use the RabbitMQ publisher confirms
AMQP extension.
"""
name = "fedora-messaging-servicev2"
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)
@defer.inlineCallbacks
def stopService(self):
"""
Gracefully stop the service.
Returns:
defer.Deferred: a Deferred which is triggered when the service has
finished shutting down.
"""
self._service.factory.stopTrying()
yield self._service.factory.stopFactory()
yield service.MultiService.stopService(self)
def makeService(config):
event_db = Event_DB(config['eventdb'])
LoopingCall(event_db.prune, MAX_AGE).start(PRUNE_INTERVAL)
broker_service = MultiService()
if config['broadcast']:
broadcaster_factory = VOEventBroadcasterFactory(
config["local-ivo"], config['broadcast-test-interval']
)
if log.LEVEL >= log.Levels.INFO: broadcaster_factory.noisy = False
broadcaster_service = TCPServer(
config['broadcast-port'],
broadcaster_factory
)
broadcaster_service.setName("Broadcaster")
broadcaster_service.setServiceParent(broker_service)
# If we're running a broadcast, we will rebroadcast any events we
# receive to it.
config['handlers'].append(EventRelay(broadcaster_factory))
if config['receive']:
receiver_factory = VOEventReceiverFactory(
local_ivo=config['local-ivo'],
validators=[
CheckPreviouslySeen(event_db),
CheckSchema(
os.path.join(comet.__path__[0], "schema/VOEvent-v2.0.xsd")
),
CheckIVORN()
],
handlers=config['handlers']
)
if log.LEVEL >= log.Levels.INFO: receiver_factory.noisy = False
whitelisting_factory = WhitelistingFactory(receiver_factory, config['whitelist'])
if log.LEVEL >= log.Levels.INFO: whitelisting_factory.noisy = False
receiver_service = TCPServer(config['receive-port'], whitelisting_factory)
receiver_service.setName("Receiver")
receiver_service.setServiceParent(broker_service)
for host, port in config["remotes"]:
subscriber_factory = VOEventSubscriberFactory(
local_ivo=config["local-ivo"],
validators=[CheckPreviouslySeen(event_db)],
handlers=config['handlers'],
filters=config['filters']
)
if log.LEVEL >= log.Levels.INFO: subscriber_factory.noisy = False
remote_service = TCPClient(host, port, subscriber_factory)
remote_service.setName("Remote %s:%d" % (host, port))
remote_service.setServiceParent(broker_service)
if not broker_service.services:
reactor.callWhenRunning(log.warning, "No services requested; stopping.")
reactor.callWhenRunning(reactor.stop)
return broker_service
def __init__(self, host, port, user, passwd,
serviceName="cvstoys.notify", prefix=None):
self.host = host
self.port = port
self.prefix = prefix
self.listener = l = FreshCVSListener()
l.source = self
self.factory = f = FreshCVSConnectionFactory()
f.source = self
f.startGettingPerspective(user, passwd, serviceName, client=l)
TCPClient.__init__(self, host, port, f)
def startService(self): print "RconManager.startService..." self.mongo = self.getRootService().getMongo() servers = yield self.mongo.servers.find() for server in servers: print "Starting server:",server factory = getClientRconFactory(server, self) client = TCPClient(server["ip"], int(server["port"]), factory) client.setServiceParent(self) server["factory"] = factory self.servers[server["tag"]] = server print self.servers MultiService.startService(self)
def configure_services(self, configuration):
read_configuration()
for section in configuration.sections():
if section.startswith("world "):
# Bravo worlds. Grab a list of endpoints and load them.
factory = BravoFactory(section[6:])
interfaces = configuration.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 = configuration.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(section[12:])
interfaces = configuration.getlist(section, "interfaces")
for service in services_for_endpoints(interfaces, factory):
self.addService(service)
elif section.startswith("infininode "):
factory = InfiniNodeFactory(section[11:])
interfaces = configuration.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, section[4:])
client = TCPClient(factory.host, factory.port, factory)
client.setName(factory.config)
self.addService(client)
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 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 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, host, port, user, passwd, prefix=None):
self.host = host
self.port = port
self.username = user
self.password = passwd
if prefix is not None and not prefix.endswith("/"):
log.msg("WARNING: prefix '%s' should probably end with a slash" \
% prefix)
self.prefix = prefix
self.listener = l = FreshCVSListener()
l.source = self
self.factory = f = FreshCVSConnectionFactory()
f.source = self
self.creds = credentials.UsernamePassword(user, passwd)
f.startLogin(self.creds, client=l)
TCPClient.__init__(self, host, port, f)
def __init__(self, host, port, user, passwd, prefix=None):
self.host = host
self.port = port
self.username = user
self.password = passwd
if prefix is not None and not prefix.endswith("/"):
log.msg("WARNING: prefix '%s' should probably end with a slash" \
% prefix)
self.prefix = prefix
self.listener = l = FreshCVSListener()
l.source = self
self.factory = f = FreshCVSConnectionFactory()
f.source = self
self.creds = credentials.UsernamePassword(user, passwd)
f.startLogin(self.creds, client=l)
TCPClient.__init__(self, host, port, f)
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 __init__(self,
host,
port,
user,
passwd,
serviceName="cvstoys.notify",
prefix=None):
self.host = host
self.port = port
self.prefix = prefix
self.listener = l = FreshCVSListener()
l.source = self
self.factory = f = FreshCVSConnectionFactory()
f.source = self
f.startGettingPerspective(user, passwd, serviceName, client=l)
TCPClient.__init__(self, host, port, f)
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 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 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)
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)
port = configuration.getint("web", "port")
server = TCPServer(port, factory)
server.setName("web")
self.addService(server)
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(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)
if self.irc:
for section in self.ircbots:
factory = BravoIRC(self.factorylist, section[4:])
client = TCPClient(factory.host, factory.port, factory)
client.setName(factory.config)
self.addService(client)
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 _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 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 _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
class Service(service.MultiService):
def __init__(self, interface, port, protocol_factory):
service.MultiService.__init__(self)
self._interface = interface
self._port = port
self._protocol_factory = protocol_factory
self._tcp_client = None
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 stopService(self):
return service.MultiService.stopService(self)
def request(self, message):
return self._protocol_factory.request(message)
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 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 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 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 startService(self):
cfgpr = ConfigParser()
# TODO: config location from argparse or something
cfgpr.read('config/config.ini')
ip = cfgpr.get('main', 'ip')
port = cfgpr.getint('main', 'port')
tag = cfgpr.get('main', 'tag')
password = cfgpr.get('main', 'password')
server_data = {
'ip': ip,
'port': port,
'tag': tag, # TODO: what is this:
'secret': password, # TODO: refactor how this kind of data is passed and stored in factory
}
factory = getClientRconFactory(server_data)
client = TCPClient(server_data["ip"], server_data["port"], factory)
client.setServiceParent(self)
self.server["factory"] = factory
MultiService.startService(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)
class Service(service.MultiService):
def __init__(self, interface, port, protocol_factory):
service.MultiService.__init__(self)
self._interface = interface
self._port = port
self._protocol_factory = protocol_factory
self._tcp_client = None
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 stopService(self):
return service.MultiService.stopService(self)
def request(self, message):
return self._protocol_factory.request(message)
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)
class MaestroMasterClientService(service.MultiService):
implementer(IAuthService)
@staticmethod
def build(punitive_model, config):
host = config.get('host')
port = config.get('port')
register_port = config.get('register_port')
domains = config.get('domains')
punitive_model_adapter = PunitiveModelAdapter(punitive_model)
protocol_factory = MaestroProtocolFactory(punitive_model_adapter, host,
register_port)
return MaestroMasterClientService(port,
protocol_factory,
interface=host,
domains=domains)
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 handles_domain(self, auth_domain):
return auth_domain in self._domains
def try_authenticate(self, auth_domain, auth_name):
return self._protocol_factory.try_auth(auth_domain, auth_name)
def answer_challenge(self, auth_domain, auth_id, answer):
return self._protocol_factory.answer_challenge(auth_id, answer)
def makeService(self, options):
"""
Create a service which will run a IrcBot server.
@param options: mapping of configuration
"""
from forthbot.ircBot import BotFactory
from twisted.python.filepath import FilePath
from twisted.internet import reactor
from twisted.application.service import MultiService
port = options['port']
server = options['server']
channel = options['channel']
nickname = options['nick']
logfile = channel + '.log'
f = BotFactory(channel, logfile, nickname)
service = MultiService()
tcp = TCPClient(server, port, f)
tcp.setName('TCP_SERVICE_ircbot')
tcp.setServiceParent(service)
return 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 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 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 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 __init__(self, overlord, freeswitch):
TCPClient.__init__(self, freeswitch["address"], freeswitch["port"], overlord.factory)
return dfr
def root_received(self, root):
self._root = root
#d = result.callRemote("get_data_point", "connections_count")
self.call("set_config", "PUSH_SHARES__MINING_SLOTS", True)
self.call("set_config", "PUSH_SHARES__MINING_SHARES", False)
#d = result.callRemote('explore', 'for_sessions', ('!', 'sess_stats'))
#d = result.callRemote('explore', 'for_sessions',
# ('limit', 2), ('!', 'sess_convert'))
#d = result.callRemote('reconnect', -1, 50)
#d = result.callRemote('cancel_reconnect')
#d = result.callRemote('get_reconnect_state')
reactor.callLater(2, reactor.stop)
def print_response(self, response, args):
print "%s\n%s" % (args, self._pp.pformat(response))
e = EchoClient()
client_factory = pb.PBClientFactory()
d = client_factory.getRootObject()
d.addCallback(e.root_received)
application = Application("echo")
client_service = TCPClient("localhost", 3201, client_factory)
client_service.setServiceParent(application)
def _connect(self, worker, timeout, bindAddress):
service = TCPClient(self.options['hostname'], self.options['port'],
AmqpFactory(worker), timeout, bindAddress)
service.setServiceParent(worker)
verbose = True
config = dict(hello="mum", goodbye="friend")
callbacks = {
"player_play": lambda player: "Callback for Player '%s'" % (player)
}
top_service = MultiService()
reader = None
if ncurses_enabled:
std_screen = curses.initscr()
reader = Screen(std_screen)
std_screen.refresh()
reactor.addReader(reader)
sbs_service = SqueezeboxServerService(reader=reader,
config=config,
callbacks=callbacks,
verbose=verbose)
sbs_service.setServiceParent(top_service)
factory = SqueezeboxServerFactory(sbs_service)
tcp_service = TCPClient(host, port, factory)
tcp_service.setServiceParent(top_service)
application = Application("pysqueezeboxserver")
top_service.setServiceParent(application)
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
class CarbonClientService(service.MultiService):
'''A Twisted service which makes recording metrics with Carbon easy.'''
def __init__(self, reactor, hostname, port):
'''Construct a CarbonClientService.
Args:
reactor: The Twisted reactor for your application.
hostname: The hostname of your Carbon server.
port: The port that the Carbon pickle endpoint is listening on.
'''
service.MultiService.__init__(self)
self._reactor = reactor
self._hostname = hostname
self._port = port
self._client_factory = None
self._tcp_client = None
self._repeating_metric_handles = []
def publish_metric(self, metric_name, metric_value, epoch_seconds=None):
'''Record a single hit on a given metric.
Args:
metric_name: The name of the metric to record with Carbon.
metric_value: The value to record with Carbon.
epoch_seconds: Optionally specify the time for the metric hit.
Returns:
None
'''
if epoch_seconds is None:
epoch_seconds = self._reactor.seconds()
self._client_factory.publish_metric(metric_name, metric_value, int(epoch_seconds))
def register_repeating_metric(self, metric_name, frequency, getter):
'''Record hits to a metric at a specified interval.
Args:
metric_name: The name of the metric to record with Carbon.
frequency: The frequency with which to poll the getter and record the value with Carbon.
getter: A function which takes no arguments and returns the value to record with Carbon.
Returns:
RepeatingMetricHandle instance. Call .stop() on it to stop recording the metric.
'''
l = task.LoopingCall(self._publish_repeating_metric, metric_name, getter)
repeating_metric_handle = RepeatingMetricHandle(l, frequency)
self._repeating_metric_handles.append(repeating_metric_handle)
if self.running:
repeating_metric_handle.start()
return repeating_metric_handle
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 stopService(self):
for repeating_metric_handle in self._repeating_metric_handles:
repeating_metric_handle.stop()
return service.MultiService.stopService(self)
def _publish_repeating_metric(self, metric_name, getter):
self.publish_metric(metric_name, getter())
class JabberClient(object):
implements(IDroneDService) #requirement
xmlstream = None
connected = property( lambda self: self.xmlstream is not None )
parentService = None #interface required attribute
service = None #interface required attribute
SERVICENAME = 'jabber' #interface required attribute
#this should be overrode in romeo
SERVICECONFIG = dictwrapper({
'JABBER_CHAT_NICK': config.HOSTNAME,
'JABBER_USERNAME': '******',
'JABBER_PASSWORD': '******',
'JABBER_SERVER': 'jabber.example.net',
'JABBER_CHAT_SERVICE': 'conference.jabber.example.net',
'JABBER_PORT': 5222,
'JABBER_RESOURCE': config.HOSTNAME,
'JABBER_BROADCAST_INTERVAL': 300,
'JABBER_VALIDATE_XML': True,
'JABBER_TRUST_ROOM': False,
'DEPUTY': '*****@*****.**',
'JABBER_TEAM_ROSTER': '/var/lib/droned/teams',
'CONVERSATION_RESPONSE_PERIOD': 180,
'JABBER_JOIN_CHATROOM': False,
'JABBER_TEAM_ROSTER': os.path.join(config.DRONED_HOMEDIR, 'teams'),
}) #interface required attribute
def running(self):
"""interface requirement"""
return bool(self.service) and self.service.running
def install(self, _parentService):
"""interface requirement"""
self.parentService = _parentService
user = self.SERVICECONFIG.JABBER_USERNAME
server = self.SERVICECONFIG.JABBER_SERVER
resource = self.SERVICECONFIG.JABBER_RESOURCE
self.jid = JID("%(user)s@%(server)s/%(resource)s" % locals())
self.broadcastTask = LoopingCall(self.broadcastPresence)
self.sendQueue = []
self.authenticated = False
#load all jabber responders, after configuration
import droned.responders
droned.responders.loadAll()
def start(self):
"""interface requirement"""
if self.running(): return
self.factory = XMPPClientFactory(self.jid, 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
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 stop(self):
"""interface requirement"""
if self.service:
self.factory.stopTrying()
self.factory.stopFactory()
self.service.disownServiceParent()
self.service.stopService()
self.service = None
def connectionMade(self, xmlstream):
log('connection made')
self.xmlstream = xmlstream
def connectionLost(self, xmlstream):
log('connection lost')
self.authenticated = False
if self.broadcastTask.running:
self.broadcastTask.stop()
if self.connected:
Event('jabber-offline').fire()
self.xmlstream = None
def connectionAuthenticated(self, xmlstream):
log('connection authenticated')
self.authenticated = True
if not self.broadcastTask.running:
self.broadcastTask.start(self.SERVICECONFIG.JABBER_BROADCAST_INTERVAL)
xmlstream.addObserver('/message', self.receivedMessage)
xmlstream.addObserver('/presence', self.receivedPresence)
xmlstream.addObserver('/iq', self.receivedIQ)
xmlstream.addObserver('/error', self.receivedError)
Event('jabber-online').fire()
while self.sendQueue:
self.xmlstream.send( self.sendQueue.pop(0) )
def broadcastPresence(self):
presence = Element( ('jabber:client','presence') )
#log('sending presence broadcast')
self.xmlstream.send(presence)
def sendMessage(self, to, body, useHTML=True, groupChat=False):
message = Element( ('jabber:client','message') )
message['to'] = to
message['type'] = (groupChat and 'groupchat') or 'chat'
message.addElement('body', None, body)
if useHTML:
html = message.addElement('html', 'http://jabber.org/protocol/xhtml-im')
htmlBody = html.addElement('body', 'http://www.w3.org/1999/xhtml')
htmlBody.addRawXml( unicode(body) )
if self.SERVICECONFIG.JABBER_VALIDATE_XML:
validateXml( html.toXml() )
#safeXml = filter(lambda char: ord(char) < 128, message.toXml())
#log('sending message: %s' % safeXml)
log('sending message to %s: %s' % (to, body))
if self.authenticated:
self.xmlstream.send(message)
else:
log("not connected, queueing message", warning=True)
self.sendQueue.append(message)
def requestAuthorization(self, to):
request = Element( (None,'iq') )
request['type'] = 'set'
request['id'] = 'auth-request:%s' % to
query = Element( (None,'query') )
query['xmlns'] = 'jabber:iq:roster'
item = Element( (None,'item') )
item['jid'] = to
item['name'] = to.split('@')[0]
query.addChild(item)
request.addChild(query)
log('sending auth request: %s' % request.toXml())
self.xmlstream.send(request)
def joinChatRoom(self, room):
presence = Element( (None,'presence') )
presence['from'] = self.jid.userhost()
jid = '%s@%s/%s' % (room,self.SERVICECONFIG.JABBER_CHAT_SERVICE,self.SERVICECONFIG.JABBER_CHAT_NICK)
presence['to'] = jid
x = Element( ('http://jabber.org/protocol/muc','x') )
history = Element( (None,'history') )
history['maxchars'] = '0'
x.addChild(history)
presence.addChild(x)
log('sending join: %s' % presence.toXml())
self.xmlstream.send(presence)
def leaveChatRoom(self, jid):
if '/' not in jid:
jid += '/' + self.SERVICECONFIG.JABBER_CHAT_NICK
presence = Element( (None,'presence') )
presence['from'] = self.jid.userhost()
presence['to'] = jid
presence['type'] = 'unavailable'
log('sending leave: %s' % presence.toXml())
self.xmlstream.send(presence)
def receivedMessage(self, e):
# Extract the body of the message
try:
message = str([c for c in e.children if c.name == 'body'][0])
except:
log('discarding invalid message (has no body!): %s' % e.toXml())
return
# Discard delayed messages
delays = [ x for x in e.children if x.name == 'delay' ]
stamps = [ x for x in e.children \
if x.name == 'x' and \
x.compareAttribute('xmlns','jabber:x:delay') and \
x.hasAttribute('stamp') ]
#stampstring = str( stamps[0].getAttribute('stamp') )
#timestamp = time.mktime( time.strptime(stampstring, "%Y%m%dT%H:%M:%S") )
if delays or stamps:
log('discarding delayed message: %s' % e.toXml())
return
# Route message to the right Conversation or ChatRoom entity
if e.getAttribute('type') == 'chat':
buddy = str( e['from'].split('/')[0] )
if not Conversation.exists(buddy):
self.requestAuthorization(buddy)
log('received message from %s: %s' % (buddy.split('@')[0], message))
Conversation(buddy).hear(message)
elif e.getAttribute('type') == 'groupchat':
room = e['from'].split('@')[0]
log('received message [chatroom=%s]: %s' % (room, message))
ChatRoom(room).hear(message)
else:
log('received message of unknown type: %s' % e.toXml(), error=True)
def receivedPresence(self, e):
log('received presence: %s' % e.toXml())
if e.getAttribute('type') == 'subscribe':
log('received authorization request from %s' % e['from'])
response = Element( ('','presence') )
response['to'] = e['from']
response['type'] = 'subscribed'
log('sending auth response: %s' % response.toXml())
self.xmlstream.send(response)
buddy = str(e['from'])
if not Conversation.exists(buddy):
self.requestAuthorization(buddy)
elif e.getAttribute('type') == 'unavailable':
#fix for openfire jabber server randomly kicking clients out and prevent kicks
CHAT = '@%s/%s' % (self.SERVICECONFIG.JABBER_CHAT_SERVICE,self.SERVICECONFIG.JABBER_CHAT_NICK)
if e['to'] == self.jid.full() and e['from'].endswith(CHAT) and \
"status code='307'" in e.toXml():
try:
log('%s has kicked me' % (e['from'],))
self.joinChatRoom(e['from'].split(CHAT)[0])
log('successfully rejoined room')
except:
err('Failed to recover from /kick')
#elif any(1 for c in e.children if c.name == 'x'):
#TODO detect buddies that go offline
# if we have a Conversation then unsubscribe .notify from all events
def receivedIQ(self, e):
log('received iq: %s' % e.toXml())
def receivedError(self, f):
log('received error: %s' % str(f))
def initFailed(self, failure):
log('Failed to initialize jabber connection:\n%s' % failure.getTraceback())
self.stop()
if failure.check(SASLAuthError):
log('Will attempt to reconnect in 15 seconds...')
reactor.callLater(15, self.start)
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 startService(self):
super(MessageSender, self).startService()
self.amqp_service = TCPClient(
self.amqp_config['hostname'], self.amqp_config['port'],
self.factory)
self.amqp_service.setServiceParent(self)
