def connect(self, hostname, domain, username, password):
"""
Connects to username@domain with specified password
Arguments:
hostname: XMPP server address
domain: XMPP domain name
username: User name
password: User password
"""
if self.connector and self.is_connected:
self.disconnect()
self.hostname = hostname
self.domain = domain
self.username = username
self.password = password
myJid = jid.JID('%s@%s/Ahenk' % (self.username, self.domain))
factory = client.XMPPClientFactory(myJid, self.password)
factory.clientConnectionLost = self.__event_connection_lost
factory.clientConnectionFailed = self.__event_connection_failed
factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT,
self.__event_session_start)
self.is_connected = True
self.connector = reactor.connectTCP(self.hostname, 5222, factory)
def testBasic(self):
"""
Test basic operations.
Setup an XMPPClientFactory, which sets up an XMPPAuthenticator, and let
it produce a protocol instance. Then inspect the instance variables of
the authenticator and XML stream objects.
"""
self.client_jid = jid.JID('[email protected]/resource')
# Get an XmlStream instance. Note that it gets initialized with the
# XMPPAuthenticator (that has its associateWithXmlStream called) that
# is in turn initialized with the arguments to the factory.
xs = client.XMPPClientFactory(self.client_jid,
'secret').buildProtocol(None)
# test authenticator's instance variables
self.assertEqual('example.com', xs.authenticator.otherHost)
self.assertEqual(self.client_jid, xs.authenticator.jid)
self.assertEqual('secret', xs.authenticator.password)
# test list of initializers
version, tls, sasl, bind, session = xs.initializers
self.assert_(isinstance(tls, xmlstream.TLSInitiatingInitializer))
self.assert_(isinstance(sasl, SASLInitiatingInitializer))
self.assert_(isinstance(bind, client.BindInitializer))
self.assert_(isinstance(session, client.SessionInitializer))
self.assertFalse(tls.required)
self.assertTrue(sasl.required)
self.assertFalse(bind.required)
self.assertFalse(session.required)
def xmpp_go(options, q_in, q_out):
"""
Main event loop for XMPP worker
"""
global Q_IN, Q_OUT, OPTIONS, myJid, factory
Q_IN = q_in
Q_OUT = q_out
OPTIONS = options
myJid = jid.JID('%s@%s/Ahenk' % (OPTIONS.username, OPTIONS.domain))
factory = client.XMPPClientFactory(myJid, OPTIONS.password)
factory.clientConnectionLost = event_connection_lost
factory.clientConnectionFailed = event_connection_failed
factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, event_session_start)
factory.addBootstrap(xmlstream.INIT_FAILED_EVENT, event_init_failed)
# Send messages in queue every 0.1 seconds
task.LoopingCall(task_message_queue).start(1.0)
# Connect to XMPP server
connect()
try:
reactor.run()
except:
pass
def __init__(self,
bot_jid,
password,
jid_to,
text,
interval,
db,
verbose=0):
self._jid = bot_jid
self._jid_to = jid_to
self._msg = domish.Element((None, "message"))
self._msg["to"] = jid_to
self._msg["type"] = "chat"
self._msg.addElement("body", content=text)
self._interval = interval
self._db = db
self._verbose = verbose
jid_obj = jid.JID(bot_jid)
# TODO: Remove CheckVersionInitializer?
factory = client.XMPPClientFactory(jid_obj, password)
factory.maxRetries = 0
factory.clientConnectionFailed = self._failed
factory.addBootstrap(STREAM_CONNECTED_EVENT, self._connected)
factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self._authd)
factory.addBootstrap(xmlstream.INIT_FAILED_EVENT, self._failed)
reactor.connectTCP(jid_obj.host, 5222, factory, timeout=10)
def make_jabber_client(resource_prefix):
""" Generate a jabber client, please """
myjid = jid.JID("%s@%s/%s_%s" % (
SETTINGS.get("pywwa_jabber_username", "nwsbot_ingest"),
SETTINGS.get("pywwa_jabber_domain", "nwschat.weather.gov"),
resource_prefix,
datetime.datetime.utcnow().strftime("%Y%m%d%H%M%S"),
))
factory = jclient.XMPPClientFactory(
myjid, SETTINGS.get("pywwa_jabber_password", "secret"))
jabber = JabberClient(myjid)
factory.addBootstrap("//event/stream/authd", jabber.authd)
factory.addBootstrap("//event/client/basicauth/invaliduser", debug)
factory.addBootstrap("//event/client/basicauth/authfailed", debug)
factory.addBootstrap("//event/stream/error", debug)
factory.addBootstrap(xmlstream.STREAM_END_EVENT, jabber.disconnect)
reactor.connectTCP(
SETTINGS.get("pywwa_jabber_host", "localhost"), # @UndefinedVariable
5222,
factory,
)
return jabber
def test_tlsConfiguration(self):
"""
A TLS configuration is passed to the TLS initializer.
"""
configs = []
def init(self, xs, required=True, configurationForTLS=None):
configs.append(configurationForTLS)
self.client_jid = jid.JID('[email protected]/resource')
# Get an XmlStream instance. Note that it gets initialized with the
# XMPPAuthenticator (that has its associateWithXmlStream called) that
# is in turn initialized with the arguments to the factory.
configurationForTLS = ssl.CertificateOptions()
factory = client.XMPPClientFactory(
self.client_jid, 'secret', configurationForTLS=configurationForTLS)
self.patch(xmlstream.TLSInitiatingInitializer, "__init__", init)
xs = factory.buildProtocol(None)
# test list of initializers
version, tls, sasl, bind, session = xs.initializers
self.assertIsInstance(tls, xmlstream.TLSInitiatingInitializer)
self.assertIs(configurationForTLS, configs[0])
def _connect(self):
self.status = 'CONNECTING'
if self.hostname != None:
self.xmpp_user = self.username + "@" + self.hostname
else:
self.xmpp_user = self.username + "@" + self.server
q.logger.log(
"[XMPPCLIENT] Connecting to server %s with xmpp user %s'" %
(self.server, self.xmpp_user))
c = client.XMPPClientFactory(jid.JID(self.xmpp_user), self.password)
c.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self._connected)
c.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self._authenticated)
c.addBootstrap(xmlstream.INIT_FAILED_EVENT, self._init_failed)
c.addBootstrap(xmlstream.STREAM_END_EVENT, self._end_stream)
def _do_connect():
self.connector = SRVConnector(reactor, 'xmpp-client', self.server,
c)
self.connector.pickServer = lambda: (self.server, 5222)
self.connector.connect()
reactor.callInThread(_do_connect)
def __init__(self, client_jid, secret):
f = client.XMPPClientFactory(client_jid, secret)
f.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected)
f.addBootstrap(xmlstream.STREAM_END_EVENT, self.disconnected)
f.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
f.addBootstrap(xmlstream.INIT_FAILED_EVENT, self.init_failed)
connector = XMPPClientConnector(reactor, client_jid.host, f)
connector.connect()
def connect():
myJid = jid.JID('%s@%s' % (OPTIONS.username, OPTIONS.domain))
factory = client.XMPPClientFactory(myJid, OPTIONS.password)
factory.clientConnectionLost = event_connection_lost
factory.clientConnectionFailed = event_connection_failed
factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, event_session_start)
factory.addBootstrap(xmlstream.INIT_FAILED_EVENT, event_init_failed)
reactor.connectTCP(OPTIONS.domain, 5222, factory)
def __init__(self, reactor, jid, secret):
self.reactor = reactor
f = client.XMPPClientFactory(jid, secret)
f.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected)
f.addBootstrap(xmlstream.STREAM_END_EVENT, self.disconnected)
f.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
f.addBootstrap(xmlstream.INIT_FAILED_EVENT, self.init_failed)
connector = SRVConnector(reactor, "xmpp-client", jid.host, f, defaultPort=5222)
connector.connect()
self.finished = Deferred()
def __init__(self, client_jid, secret, to_jid, message, check_online=True):
self.client_jid = client_jid
self.to_jid = to_jid
self.message = message
self.check_online = check_online
f = client.XMPPClientFactory(client_jid, secret)
f.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected)
f.addBootstrap(xmlstream.STREAM_END_EVENT, self.disconnected)
f.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
f.addBootstrap(xmlstream.INIT_FAILED_EVENT, self.init_failed)
connector = XMPPClientConnector(reactor, client_jid.host, f)
connector.connect()
def __init__(self, service):
jid = JID('127.0.0.1')
f = client.XMPPClientFactory(jid, '')
f.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected)
f.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
connector = SRVConnector(reactor,
'xmpp-client',
jid.host,
f,
defaultPort=6523)
connector.connect()
self.finished = Deferred()
self.files = {}
self.service = service
def init(self):
self.username, self.server = self.mirror('username').split('@')
self.password = self.mirror('password')
listener = self.parent().get_listener(self._id)
self.resource = listener['resource']
self.nickname = listener['nickname']
jid = "%s@%s/%s" % (self.username, self.server, self.resource)
self.jid = JID(jid)
self.f = client.XMPPClientFactory(self.jid, self.password)
self.con = SRVConnector(reactor,
'xmpp-client',
self.jid.host,
self.f,
defaultPort=5222)
def __init__(self):
super(XmppMessenger, self).__init__()
self.me = jid.JID(config()['xmpp']['me'])
self.xmlstream = False
self.kaTimer = None
self.kaResponseTimer = None
self.lastSendTime = datetime.datetime.today() - datetime.timedelta(
days=1)
f = client.XMPPClientFactory(self.me, config()['xmpp']['password'])
f.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected)
f.addBootstrap(xmlstream.STREAM_END_EVENT, self.disconnected)
f.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
f.addBootstrap(xmlstream.INIT_FAILED_EVENT, self.init_failed)
self.connector = XMPPClientConnector(reactor, self.me.host, f)
self.connect()
def __init__(self, user, password, host=None, port=5222, resource=None):
self.xmlstream = None
self.user, self.host = user.split('@')
self.server = host or self.host
self.resource = resource or socket.gethostname()
self.jid = jid.JID(tuple=(self.user, self.host, self.resource))
self.full = self.jid.full()
self.cids = {}
factory = client.XMPPClientFactory(self.jid, password)
factory.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected)
factory.addBootstrap(xmlstream.STREAM_END_EVENT, self.disconnected)
factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
factory.addBootstrap(xmlstream.INIT_FAILED_EVENT, self.init_failed)
factory.addBootstrap('/iq/bind/jid', self.bind)
logger.info('Connecting %s' % str(self))
reactor.connectTCP(self.server, 5222, factory)
def __init__(self, app, client_jid, secret):
self.app = app
self.factory = client.XMPPClientFactory(client_jid, secret)
self.factory.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT,
self.connected)
self.factory.addBootstrap(xmlstream.STREAM_END_EVENT,
self.disconnected)
self.factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT,
self.authenticated)
self.factory.addBootstrap(xmlstream.INIT_FAILED_EVENT, self.initFailed)
self.factory.startedConnecting = self.startedConnecting
self.connector = tcp.XMPPConnector(reactor,
client_jid.host,
self.factory,
defaultPort=5222)
self.iq_ctr = 0
def make_plugin(config):
p = JabberPlugin()
jabber_config = JabberConfig(config)
# set up the jabber bot
id = jid.JID(jabber_config.id)
factory = client.XMPPClientFactory(id, jabber_config.password)
manager = xmlstream.StreamManager(factory)
bot = JabberBot(p)
bot.setHandlerParent(manager)
p.bot = bot
p.add_service(
internet.TCPClient(jabber_config.host, jabber_config.port, factory))
# add the built-in commands
p.register_command(help)
return p
def invaliduserEvent(self, xmlstream):
print "Invalid User"
def registerfailedEvent(self, xmlstream):
print 'Register failed!'
if __name__ == '__main__':
# Parametrizamos la conexion
PASSWORD = '******'
myJid = jid.JID('test_user@test-xmpp')
me = 'test_user@test-xmpp'
factory = client.XMPPClientFactory(myJid, PASSWORD)
# Registramos las callbacks de autentificacion
print 'register callbacks'
factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, authd)
factory.addBootstrap(client.BasicAuthenticator.INVALID_USER_EVENT,
invaliduserEvent)
factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT,
authfailedEvent)
factory.addBootstrap(client.BasicAuthenticator.REGISTER_FAILED_EVENT,
registerfailedEvent)
# Paarametrizamos y arrancamos el reactor (encargado de mantener y gestionar las callbacks
# producidas por las acciones de la conexion)
reactor.connectTCP('localhost', 5222, factory)
reactor.run()
def __init__(self,
device,
user='******',
secret='password',
userlist=[],
web_server=None):
self.log = Logger()
self.description = None
self.reactor = reactor
self.user = user
self.services = {}
self.nodes = []
self.registrations = []
self.active_controllers = []
self.webserver = web_server
self.resource = web_server.resource
device.location = user
def _map_context(ctx):
ctx.udc = UserDefinedContext(device.player)
self._jid = _jid = ''.join(
(user, '/', device.deviceType, ':uuid:', device.uuid))
self.device = device
device.parent = self
for service in device.services:
# if appreg.get_application(service.tns, service.name):
# name = service.name + '_'
# else:
# name = service.name
# soap_service = type(
# service.name, (ServiceBase,), service.soap_functions)
# soap_service.tns = service.tns
# app = Application(
# [soap_service],
# tns=soap_service.tns,
# in_protocol=Soap11(xml_declaration=False),
# out_protocol=Soap11(xml_declaration=False),
# name=name)
# app.event_manager.add_listener('method_call', _map_context)
self.services.update({
str(service.serviceId): {
'app': TwistedXMPPApp(service.app),
'svc': service
}
})
print('name: %s, methods: %s' %
(device.name, service.app.interface.service_method_map))
for var in service.stateVariables.values():
if var.sendEvents:
self.nodes.append((var, service.serviceType, service))
self.users = {user: False}
for user in userlist:
self.users.update({user: False})
self.jid = jid = JID(_jid)
self.factory = f = client.XMPPClientFactory(jid, secret)
f.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected)
f.addBootstrap(xmlstream.STREAM_END_EVENT, self.disconnected)
f.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
f.addBootstrap(xmlstream.INIT_FAILED_EVENT, self.init_failed)
# self.get_device_info(device)
self.finished = defer.Deferred()
def __init__(
self, parent=None, searchables=None, xmldir=None,
network='lan', cloud_user=None, cloud_servers=[],
logger=None, uid=None, messager=None):
self.connected = False
self.messager = messager
self.app_paused = False
self.fail_count = 0
if not logger:
self.log = Logger()
else:
self.log = logger
self.log.debug('UPnP controller starts')
self.xmldir = xmldir
self.devices = {}
self._services = {}
self.parent = parent
# self.amp = ControllerAmp(self)
if uid:
self.uuid = uid
else:
self.uuid = str(
uuid.uuid5(
uuid.NAMESPACE_DNS,
socket.gethostname() + 'onDemand_Controller'))
if searchables:
for typ in searchables:
self.searchables.update({typ[0]: typ[1]})
# print(self.searchables)
else:
self.searchables = {'upnp:rootdevice': self.log.debug}
if network in ('lan', 'both'):
self.log.debug('UPnP classic enabled')
self.lan = True
self.listener = ssdp.SSDP_Listener(self)
self.mcast = internet.MulticastServer( # @UndefinedVariable
SSDP_PORT,
self.listener,
listenMultiple=True,
interface=SSDP_ADDR_V4)
self.mcast.setServiceParent(self)
self.ssdp_cli = ssdp.SSDP_Client(
self, get_default_v4_address(), device=False)
self.ucast = internet.UDPServer( # @UndefinedVariable
0, self.ssdp_cli, self.ssdp_cli.interface)
self.ucast.setServiceParent(self)
# self.agent = Agent(reactor)
if network in ('cloud', 'both'):
if cloud_user:
self.log.debug('UPnP Cloud enabled')
self.cloud = True
self._jid, secret = cloud_user
self.users = {self._jid: {'state': True}}
for user in cloud_servers:
self.users.update({user: {'state': False}})
self.hosts = {}
self.resourcepart = ''.join((
'urn:schemas-upnp-org:cloud-1-0:ControlPoint:1:uuid:',
self.uuid))
full_jid = ''.join(
(self._jid, '/', self.resourcepart))
self.jid = jid = JID(full_jid)
self.reactor = reactor
f = client.XMPPClientFactory(jid, secret)
f.addBootstrap(
xmlstream.STREAM_CONNECTED_EVENT, self.cloud_connected)
f.addBootstrap(
xmlstream.STREAM_END_EVENT, self.cloud_disconnected)
f.addBootstrap(
xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
f.addBootstrap(
xmlstream.INIT_FAILED_EVENT, self.cloud_failed)
self.connector = endpoints.HostnameEndpoint(
reactor, jid.host, 5222)
self.factory = f
