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