def test_basic(self): """ Authenticator and stream are properly constructed by the factory. The L{xmlstream.XmlStream} protocol created by the factory has the new L{client.BasicAuthenticator} instance in its C{authenticator} attribute. It is set up with C{jid} and C{password} as passed to the factory, C{otherHost} taken from the client JID. The stream futher has two initializers, for TLS and authentication, of which the first has its C{required} attribute set to C{True}. """ 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.basicClientFactory(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 tls, auth = xs.initializers self.assertIsInstance(tls, xmlstream.TLSInitiatingInitializer) self.assertIsInstance(auth, client.IQAuthInitializer) self.assertFalse(tls.required)
def connect(self): """connect to the jabber server""" self.dprint('Starting to connect') self.dprint('Building context factory for jid %s' % self.jidString(self.userId)) jidStr = self.jidString(self.userId) self._fact = factory = client.basicClientFactory(jid.JID(jidStr), self.userPassword) factory.addBootstrap('//event/stream/authd', self.authenticate) factory.addBootstrap(client.BasicAuthenticator.INVALID_USER_EVENT, self.invalidUser) factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, self.fatalError) factory.addBootstrap(client.BasicAuthenticator.REGISTER_FAILED_EVENT, self.fatalError) self.dprint('connecting to server %s using id %s...' % (self.server, self.userId)) if self.wants_ssl: class contextFactory: isClient = 1 method = ssl.SSL.SSLv3_METHOD def getContext(self): context = ssl.SSL.Context(self.method) return context self.dprint('Connecting with ssl...') ctxFactory = contextFactory() reactor.connectSSL(self.host, self.port, factory, ctxFactory) else: reactor.connectTCP(self.host, self.port, factory) return reactor
def basic_connect(jabberid, secret, host, port, cb, v=0): myJid = jid.JID(jabberid) factory = client.basicClientFactory(myJid, secret) factory.v = v factory.addBootstrap('//event/stream/authd', cb) reactor.connectTCP(host, port, factory) return factory
def get_callback(user, password, port=5222, server=None, pubsub=None, extra="%i" % (random.randint(0, 1000))): global _user, _pass, _me, _pubsub _user = user _pass = password _pubsub = pubsub (u, host) = _user.split("@") _me = jid.JID("%s/BluetoothScanner%s" % (_user, extra)) factory = client.basicClientFactory(_me, _pass) factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, authd) factory.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, setup) factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, authfailedEvent) reactor.connectTCP(host, 5222, factory) # start it all _reactor_thread = threading.Thread(target=reactor.run, args=[0]) _reactor_thread.start() return _process
def connect(self): """connect to the jabber server""" self.dprint('Starting to connect') self.dprint('Building context factory for jid %s' % self.jidString(self.userId)) jidStr = self.jidString(self.userId) self._fact = factory = client.basicClientFactory( jid.JID(jidStr), self.userPassword) factory.addBootstrap('//event/stream/authd', self.authenticate) factory.addBootstrap(client.BasicAuthenticator.INVALID_USER_EVENT, self.invalidUser) factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, self.fatalError) factory.addBootstrap(client.BasicAuthenticator.REGISTER_FAILED_EVENT, self.fatalError) self.dprint('connecting to server %s using id %s...' % (self.server, self.userId)) if self.wants_ssl: class contextFactory: isClient = 1 method = ssl.SSL.SSLv3_METHOD def getContext(self): context = ssl.SSL.Context(self.method) return context self.dprint('Connecting with ssl...') ctxFactory = contextFactory() reactor.connectSSL(self.host, self.port, factory, ctxFactory) else: reactor.connectTCP(self.host, self.port, factory) return reactor
def connect(self): """connect to the jabber server""" self.logger.debug('Starting to connect') self.logger.debug('Building context factory for jid %s' % self.myJid) factory = client.basicClientFactory(jid.JID(self.myJid), self.password) factory.addBootstrap('//event/stream/authd', self.authenticate) self.logger.debug('Connecting to server %s (port %d) using id %s...' % (self.server, self.port, self.myJid)) if self.ssl: class contextFactory: isClient = 1 method = ssl.SSL.SSLv3_METHOD def getContext(self): context = ssl.SSL.Context(self.method) return context self.logger.debug('Connecting with ssl...') reactor.connectSSL(self.server, self.port, factory, contextFactory()) else: reactor.connectTCP(self.server, self.port, factory) return reactor
def start(self): myJid = jid.JID(self.me) factory = client.basicClientFactory(myJid, self.password) factory.addBootstrap('//event/stream/authd',self.authd) reactor.connectTCP(self.server, 5222, factory) reactor.callLater(5, self.stop) reactor.run()
def __initFactory(self): self._jid = jid.JID("%s/%s" % (self.jabberid, self.resource)) self._factory = client.basicClientFactory(self._jid, self.password) self._factory.addBootstrap('//event/stream/authd', self._authd) self._reactor.connectTCP(self.servername, self.port, self._factory) self._reactor.run()
def __init__(self): #Connect to jabber server myjid = jid.JID('tester@ejabberd/test_send') factory = client.basicClientFactory(myjid, 'tester') factory.addBootstrap('//event/stream/authd', self.authd) reactor.connectTCP('ejabberd', 5222, factory) #Set up the looping call that will be sending messages. self._lc = LoopingCall(self.sendMessage) self._xs = None
def __init__(self): #Connect to jabber server myjid = jid.JID('[email protected]/tasker') factory = client.basicClientFactory(myjid, 'mypass') factory.addBootstrap('//event/stream/authd', self.authd) reactor.connectTCP('xmpp.ecmanaged.net', 5222, factory) #Set up the looping call that will be sending messages. self._lc = LoopingCall(self.send_message) self._xs = None
def __init__(self, client_jid, secret): self.jid = client_jid self.password = secret self.f = client.basicClientFactory(client_jid, secret) self.f.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected) self.f.addBootstrap(xmlstream.STREAM_END_EVENT, self.disconnected) self.f.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated) connector = XMPPClientConnector(reactor, client_jid.host, self.f) connector.servers = [self.jid.host, 5222] connector.orderedServers = [self.jid.host, 5222] connector.connect() self.t = reactor.callLater(10, self.failed)
def __init__(self): self.tc = 0 self.th = {} self.jid = jid.JID("%s@%s/%s" % (config.USER, config.SERVER, config.RESOURCE)) self.onauthd = None self.c = client.basicClientFactory(self.jid, config.PASSWD) self.c.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authd); self.x = None self.log = log.logger() self.handlers = [] self.msghandlers = [] reactor.connectTCP(config.SERVER, 5222, self.c)
def _connect(self, host, port): myJid = jid.JID(self.jid+'/'+self.resource) self.factory = client.basicClientFactory(myJid, self.password) #self.factory.addBootstrap('//event/stream/start',self._streamstart) self.factory.addBootstrap('//event/stream/authd',self._authd) self.factory.addBootstrap("//event/client/basicauth/invaliduser", self._invaliduser) self.factory.addBootstrap("//event/client/basicauth/authfailed", self._authfailed) #self.factory.addBootstrap("//event/client/basicauth/registerfailed", self._regfailed) #self.factory.addBootstrap('/iq[@type="result"]/bind', self._bind) self.factory.clientConnectionLost = self.connectionLost self.factory.clientConnectionFailed = self.connectionFailed self.connection = reactor.connectTCP(host,port,self.factory)
def __init__(self,inf,jabber): self.config=toLow(jabber) self.informer = inf self.active = False Jabber.__init__(self) factory = client.basicClientFactory(JID.JID(self.getJID()+'/'+md5(platform.node()).hexdigest()), self.config["password"]) factory.addBootstrap("//event/stream/authd", self.onConnect) factory.addBootstrap("/iq/error", self.onAuthfail) reactor.connectTCP(self.config["host"],5222,factory) self.factory = factory
def __init__(self, userjid, password): constants.__init__(self) self.filename = 'dic_jabberusers' self.me = jid.JID(userjid) self.juser = userjid self.factory = client.basicClientFactory(self.me, password) #self.Server = xmlrpclib.ServerProxy(self.XMLRPC_PROTO + '://' + self.XMLRPC_HOST + ':' + `self.XMLRPC_PORT`) self.theXmlstream = None self.dicUsers = {} self.factory.addBootstrap('//event/stream/authd',self.authd)
def login(self, username, password): self.d = defer.Deferred() self.myJid = jid.JID(username) if self.myJid.resource is None: self.myJid.resource = 'XMPPCred' self.jfactory = client.basicClientFactory(self.myJid, password) # TODO - clean this up self.jfactory.addBootstrap("//event/stream/authd",self.authd) self.jfactory.addBootstrap("//event/client/basicauth/invaliduser", self.authe) self.jfactory.addBootstrap("//event/client/basicauth/authfailed", self.authe) self.jfactory.addBootstrap("//event/stream/error", self.authe) reactor.connectTCP(self.server,self.port,self.jfactory) return self.d
def __init__(self, config, ): self.config = config self.debug = self.config.getint('app','debug') self._load_plugins() me = jid.JID(self.config.get('bot','jid')) self.factory = client.basicClientFactory(me, self.config.get('bot','pwd')) self.factory.addBootstrap('//event/stream/authd',self.authd) self.factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, self.authfailedEvent) reactor.connectTCP(self.config.get('bot','server'), self.config.getint('bot','port'), self.factory) reactor.run() self.reactor = reactor
def rss_fetch(object, arg): feedserialized = object.get_message() feedlist = midgard.replicator.unserialize(feedserialized) print "Connecting" conn = Testing(feedserialized) me = jid.JID("[email protected]/Midgard") factory = client.basicClientFactory(me, "asdasd") factory.addBootstrap("//event/stream/authd", conn.connection) reactor.connectTCP("zindium.org", 5222, factory) reactor.startRunning() while conn.runloop: reactor.runUntilCurrent() reactor.doIteration(0) time.sleep(0.1)
def connect(self, jidVal=None, password=None): myJid = jid.JID(jidVal) if self.manager == None: self.manager = "manager@%s" % myJid.host self.jid = myJid.userhost() self.server = str(myJid.host) myJid.resource = "onlyone" factory = client.basicClientFactory(myJid, password) factory.addBootstrap('//event/stream/authd', self.authd) self.reactor.connectTCP(myJid.host, 5222, factory) if self.finish_callback != None: print "XMPP Lib: setting finish_callback" self.reactor.addSystemEventTrigger('before', signal.SIGINT, self.finish_callback) self.reactor.run() return
def login(self, username, password): self.d = defer.Deferred() self.myJid = internJID(username) if self.myJid.resource is None: self.myJid.resource = 'XMPPCred' self.jfactory = client.basicClientFactory(self.myJid, password) # TODO - clean this up self.jfactory.addBootstrap("//event/stream/authd", self.authd) self.jfactory.addBootstrap("//event/client/basicauth/invaliduser", self.authe) self.jfactory.addBootstrap("//event/client/basicauth/authfailed", self.authe) self.jfactory.addBootstrap("//event/stream/error", self.authe) reactor.connectTCP(self.server, self.port, self.jfactory) return self.d
def __init__(self, client_jid, secret, cb, i, timer = 2): self.cb = cb self.i = i + 1 self.jid = client_jid self.password = secret self.logs = "" self.f = client.basicClientFactory(client_jid, secret) self.f.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self.connected) self.f.addBootstrap(xmlstream.STREAM_END_EVENT, self.disconnected) self.f.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.authenticated) connector = XMPPClientConnector(reactor, client_jid.host, self.f) connector.servers = ["localhost", 5222] connector.orderedServers = ["localhost", 5222] connector.connect() self.t = reactor.callLater(timer, self.failed, True) self._f = False self.running = True
def on_response(self,dlg,resp): if resp == gtk.RESPONSE_OK: host = self.host.get_text() port = int(self.port.get_text()) username = self.username.get_text() password = self.password.get_text() component = self.component.get_text() self.jid = jid.JID("%s@%s/Browser"% (username,host)) factory = client.basicClientFactory(self.jid,password) factory.addBootstrap('//event/stream/authd',self.authenticated) factory.addBootstrap(client.BasicAuthenticator.INVALID_USER_EVENT, self.login_error) factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, self.login_error) reactor.connectTCP(host, port, factory) else: reactor.stop()
def on_response(self, dlg, resp): if resp == gtk.RESPONSE_OK: host = self.host.get_text() port = int(self.port.get_text()) username = self.username.get_text() password = self.password.get_text() component = self.component.get_text() self.jid = jid.JID("%s@%s/Browser" % (username, host)) factory = client.basicClientFactory(self.jid, password) factory.addBootstrap('//event/stream/authd', self.authenticated) factory.addBootstrap(client.BasicAuthenticator.INVALID_USER_EVENT, self.login_error) factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, self.login_error) reactor.connectTCP(host, port, factory) else: reactor.stop()
def get_callback(user, password, port=5222, server=None, extra = "%i" %(random.randint(0,1000)) ): global _user, _pass, _me _user = user _pass = password (u,host) = _user.split("@") _me = jid.JID("%s/BluetoothScanner%s" %(_user, extra) ) factory = client.basicClientFactory(_me, _pass) factory.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, authd) factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, authfailedEvent) reactor.connectTCP(host, 5222, factory) # start it all reactor.run() return _process
def make_jabber_client(resource_prefix): """ Generate a jabber client, please """ myJid = jid.JID('%s@%s/%s_%s' % (config.get('xmpp','username'), config.get('xmpp','domain'), resource_prefix, datetime.datetime.utcnow().strftime("%Y%m%d%H%M%S") ) ) factory = jclient.basicClientFactory(myJid, config.get('xmpp', 'password')) jabber = JabberClient(myJid) factory.addBootstrap('//event/stream/authd', jabber.authd) factory.addBootstrap("//event/client/basicauth/invaliduser", jabber.debug) factory.addBootstrap("//event/client/basicauth/authfailed", jabber.debug) factory.addBootstrap("//event/stream/error", jabber.debug) factory.addBootstrap(xmlstream.STREAM_END_EVENT, jabber._disconnect ) reactor.connectTCP(config.get('xmpp', 'connecthost'), 5222, factory) return jabber
def connect(self, password, useSSL, register, view): factory = client.basicClientFactory(self.id, password) self.connected = False if register: invalidUser = lambda x: factory.authenticator.registerAccount() else: invalidUser = self.invaliduser factory.addBootstrap('//event/stream/authd', self.authd) factory.addBootstrap("//event/client/basicauth/authfailed", self.authfailed) factory.addBootstrap("//event/client/basicauth/invaliduser", invalidUser) factory.addBootstrap("//event/stream/error", self.error) if useSSL: ssl.connectSSL(self.host, 5223, factory, view) else: reactor.connectTCP(self.host, 5222, factory)
def main(): resource = 'gatskerd' parser = OptionParser() parser.add_option('--jid', dest='jabber_id', help='set the JID', metavar='JID') parser.add_option('--pass', dest='jabber_password', help='set the password for that JID', metavar='PASSWORD') parser.add_option('--jnick', dest='jabber_nick', help='set the Jabber MUC nick', metavar='NICK', default=resource) parser.add_option('--muc', dest='jabber_channel', help='set the Jabber MUC', metavar='MUC') parser.add_option('--server', dest='irc_server', help='set the IRC server', metavar='SERVER') parser.add_option('--channel', dest='irc_channel', help='set the IRC channel', metavar='CHANNEL') parser.add_option('--nick', dest='irc_nick', help='set the IRC nick', metavar='NICK', default=resource) options, args = parser.parse_args() # create factory protocol and application irc_factory = IRCMirrorFactory(options.irc_nick, options.irc_channel) current_jid = jid.JID('%s/%s' % (options.jabber_id, resource)) jabber_factory = client.basicClientFactory(current_jid, options.jabber_password) jabber = JabberSide(current_jid, options.jabber_nick, options.jabber_channel) jabber_factory.addBootstrap('//event/stream/authd', jabber.authd) jabber_factory.addBootstrap("//event/client/basicauth/invaliduser", jabber.debug) jabber_factory.addBootstrap("//event/client/basicauth/authfailed", jabber.debug) jabber_factory.addBootstrap("//event/stream/error", jabber.debug) # connect factory to this host and port reactor.connectTCP(options.irc_server, 6667, irc_factory) reactor.connectTCP(current_jid.host, 5222, jabber_factory) # run bot reactor.run()
def connect(self): """connect to the jabber server""" self.logger.debug("Starting to connect") self.logger.debug("Building context factory for jid %s" % self.myJid) factory = client.basicClientFactory(jid.JID(self.myJid), self.password) factory.addBootstrap("//event/stream/authd", self.authenticate) self.logger.debug("Connecting to server %s (port %d) using id %s..." % (self.server, self.port, self.myJid)) if self.ssl: class contextFactory: isClient = 1 method = ssl.SSL.SSLv3_METHOD def getContext(self): context = ssl.SSL.Context(self.method) return context self.logger.debug("Connecting with ssl...") reactor.connectSSL(self.server, self.port, factory, contextFactory()) else: reactor.connectTCP(self.server, self.port, factory) return reactor
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.basicClientFactory(myJid, settings.get('pywwa_jabber_password', 'secret')) jabber = JabberClient(myJid) factory.addBootstrap('//event/stream/authd', jabber.authd) factory.addBootstrap("//event/client/basicauth/invaliduser", jabber.debug) factory.addBootstrap("//event/client/basicauth/authfailed", jabber.debug) factory.addBootstrap("//event/stream/error", jabber.debug) factory.addBootstrap(xmlstream.STREAM_END_EVENT, jabber._disconnect ) reactor.connectTCP(settings.get('pywwa_jabber_host', 'localhost'), 5222, factory) return jabber
def __init__(self, reactor, chump, uid, passwd, serv): self.chump = chump myJid = jid.JID(uid + '/twisted_words') factory = client.basicClientFactory(myJid, passwd) factory.addBootstrap('//event/stream/authd', self.authd) reactor.connectTCP(serv, 5222, factory)
def authd(xmlstream): print "authenticated" presence = domish.Element(('jabber:client', 'presence')) xmlstream.send(presence) xmlstream.addObserver('/message', debug) xmlstream.addObserver('/presence', debug) xmlstream.addObserver('/iq', debug) def authfailedEvent(xmlstream): global reactor print 'Auth failed!' reactor.stop() def debug(elem): print elem.toXml().encode('utf-8') print "=" * 20 myJid = jid.JID('*****@*****.**') factory = client.basicClientFactory(myJid, 'quant6512') factory.addBootstrap('//event/stream/authd', authd) factory.addBootstrap('//event/stream/authfailedEvent', authfailedEvent) reactor.connectTCP('talk.google.com', 5222, factory) reactor.run()
def authd(xmlstream): print "authenticated" print 'success ass hole' presence = domish.Element(('jabber:client','presence')) xmlstream.send(presence) xmlstream.addObserver('/message', debug) xmlstream.addObserver('/presence', debug) xmlstream.addObserver('/iq', debug) def debug(elem): print elem.toXml().encode('utf-8') print "="*20 try: myJid = jid.JID('*****@*****.**') print 'jabber id', myJid factory = client.basicClientFactory(myJid, 'dvdreddyreder') print 'fcc' factory.addBootstrap('//event/stream/authd',authd) try: print 'portxyz' reactor.connectTCP('http://jabber.org', 5222, factory, 135) reactor.run() except Exception: print Exception print 'xxs' print 'exx' except Exception: print Exception
def __init__(self, web_server="mugshot.org", xmpp_server=None, username=None, password=None): """Create a new TwistedModel instance that connects to the specified server. Arguments: web_server: Web server to connect to. The port may be specified by appending it after a colon. If the port is not specified, a default value will be used. (default='mugshot.org') xmpp_server: XMPP server to connect to. The port may be specified by appending it after a colon. If the port is not specified, a default value will be used. If no xmpp server is specified, the web server hostname will be used. username: GUID of the user to connect as (if not specified, found from cookies.txt) password: Password of the user (if not specified, found from cookies.txt) """ AbstractModel.__init__(self) colon = web_server.find(":") if (colon >= 0): self.web_server = web_server[:colon] self.web_port = int(web_server[colon + 1:]) else: self.web_server = web_server if web_server == "mugshot.org": self.web_port = 80 elif web_server == "dogfood.mugshot.org": self.web_port = 9080 else: self.web_port = 8080 if self.web_port == 80: web_port = "" else: web_port = ":" + `self.web_port` self.web_base_url = "http://%s%s" % (self.web_server, web_port) self.xmpp_port = None if xmpp_server != None: colon = xmpp_server.find(":") if (colon >= 0): self.xmpp_server = xmpp_server[:colon] self.xmpp_port = int(xmpp_server[colon + 1:]) else: self.xmpp_server =xmpp_server else: self.xmpp_server = self.web_server if self.xmpp_port == None: if self.web_port == 80: self.xmpp_port = 5122 else: self.xmpp_port = 21020 if username == None and password == None: username, password = _parse_cookies(self.web_server) elif username != None or password != None: raise MustLoginException("Either both user and password must be specified or neither") # FIXME: Use a legal resource self.username = username user_jid = jid.JID("%s@%s/mugshot-python" % (_guid_to_jabber_id(username), self.web_server)) self.__factory = client.basicClientFactory(user_jid, password) self._xmlstream = None
# Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # Originally written by Darryl Vandorp # http://randomthoughts.vandorp.ca/ from twisted.words.protocols.jabber import client, jid from twisted.words.xish import domish from twisted.internet import reactor def authd(xmlstream): print "authenticated" presence = domish.Element(('jabber:client','presence')) xmlstream.send(presence) xmlstream.addObserver('/message', debug) xmlstream.addObserver('/presence', debug) xmlstream.addObserver('/iq', debug) def debug(elem): print elem.toXml().encode('utf-8') print "="*20 myJid = jid.JID('[email protected]/twisted_words') factory = client.basicClientFactory(myJid, 'password') factory.addBootstrap('//event/stream/authd',authd) reactor.connectTCP('server.jabber',5222,factory) reactor.run()
# # Originally written by Darryl Vandorp # http://randomthoughts.vandorp.ca/ from twisted.words.protocols.jabber import client, jid from twisted.words.xish import domish from twisted.internet import reactor def authd(xmlstream): print "authenticated" presence = domish.Element(("jabber:client", "presence")) xmlstream.send(presence) xmlstream.addObserver("/message", debug) xmlstream.addObserver("/presence", debug) xmlstream.addObserver("/iq", debug) def debug(elem): print elem.toXml().encode("utf-8") print "=" * 20 myJid = jid.JID("[email protected]/twisted_words") factory = client.basicClientFactory(myJid, "password") factory.addBootstrap("//event/stream/authd", authd) reactor.connectTCP("server.jabber", 5222, factory) reactor.run()
print presence.toXml() xmlstream.send(presence) def sendMessage(self, message): """Send a message to the MUC""" m = domish.Element((None, 'message')) m['from'] = self.jid m['to'] = self.room m['type'] = 'groupchat' m.addElement('body', content = message) self.xmlstream.send(m) def debug(self, element): print element.toXml().encode('utf-8') print '='*20 #Jabber setup jabberClient = JabberClient() jabberFactory = client.basicClientFactory(jid.JID(jabberClient.jid), jabberClient.password) jabberFactory.addBootstrap('//event/stream/authd', jabberClient.authd) jabberFactory.addBootstrap('//event/client/basicauth/authfailed', jabberClient.debug) reactor.connectTCP(jabberClient.server, jabberClient.port, jabberFactory) #Webserver setup serverRoot = Resource() serverRoot.putChild("robot", WebServer(jabberClient)) webFactory = Site(serverRoot) reactor.listenTCP(8880, webFactory) reactor.run() #Into the hands of fate!
#after the collection node is creaed, create all children d_collection.addCallback(create_childs, d, node[2]) d_collection.addErrback(d.errback) d.addErrback(log_err, node[1]) pending.append(d) return defer.DeferredList(pending, fireOnOneErrback=1, consumeErrors=1) def authenticated(xmlstream): print "authenticated" ps = PubSub(xmlstream, PUBUSB_COMPONENT) d = add_nodes(ps, hierarchy) d.addErrback(log_err) d.addBoth(lambda _: reactor.stop()) def login_error(err_msg): print "Couldn't login", err reactor.stop() jid = jid.JID("%s@%s/Sample" % (USERNAME, HOST)) factory = client.basicClientFactory(jid, PASSWORD) factory.addBootstrap('//event/stream/authd', authenticated) factory.addBootstrap(client.BasicAuthenticator.INVALID_USER_EVENT, login_error) factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, login_error) reactor.connectTCP(HOST, PORT, factory) reactor.run()
# Copyright (c) 2009 Twisted Matrix Laboratories. # See LICENSE for details. # Originally written by Darryl Vandorp # http://randomthoughts.vandorp.ca/ from twisted.words.protocols.jabber import client, jid from twisted.words.xish import domish from twisted.internet import reactor def authd(xmlstream): print "authenticated" presence = domish.Element(('jabber:client','presence')) xmlstream.send(presence) xmlstream.addObserver('/message', debug) xmlstream.addObserver('/presence', debug) xmlstream.addObserver('/iq', debug) def debug(elem): print elem.toXml().encode('utf-8') print "="*20 myJid = jid.JID('[email protected]/twisted_words') factory = client.basicClientFactory(myJid, 'password') factory.addBootstrap('//event/stream/authd',authd) reactor.connectTCP('server.jabber',5222,factory) reactor.run()
for arg in sys.argv: if arg == 'debug': debug_flag = True if arg == 'init_schema': conn.execute("""CREATE TABLE users (user_id integer primary key autoincrement, jid text not null unique, admin integer not null default 0, preferences blob)""") conn.execute("""CREATE TABLE plugin_links (link_id integer primary key autoincrement, url text, tags text, user_id integer, time float)""") print "Schema initialized!" bacon = BaconBot(debug_flag, conn) # xmpp me = jid.JID(config.username) factory = client.basicClientFactory(me, config.password) factory.addBootstrap('//event/stream/authd', bacon.auth) reactor.connectTCP('jabber.org', 5222, factory) reactor.addSystemEventTrigger('before', 'shutdown', bacon.shutdown) # plugins registered_handlers = {} plugins.reddit.register_handlers(bacon.registered_handlers) plugins.relay.register_handlers(bacon.registered_handlers) plugins.admin.register_handlers(bacon.registered_handlers) plugins.twitter.register_handlers(bacon.registered_handlers) plugins.links.register_handlers(bacon.registered_handlers) bacon.registered_handlers[re.compile('^help')] = main_help # go!
def build(where, who, pword): myJid = jid.JID(who) factory = client.basicClientFactory(myJid, pword) factory.addBootstrap('//event/stream/authd',authd) reactor.connectTCP(where,5222,factory)
def authenticated(xmlstream): print "authenticated" ps = PubSub(xmlstream, PUBUSB_COMPONENT) d = add_nodes(ps,hierarchy) d.addErrback(log_err) d.addBoth(lambda _ : reactor.stop()) def login_error(err_msg): print "Couldn't login", err reactor.stop() jid = jid.JID("%s@%s/Sample"% (USERNAME,HOST)) factory = client.basicClientFactory(jid,PASSWORD) factory.addBootstrap('//event/stream/authd',authenticated) factory.addBootstrap(client.BasicAuthenticator.INVALID_USER_EVENT, login_error) factory.addBootstrap(client.BasicAuthenticator.AUTH_FAILED_EVENT, login_error) reactor.connectTCP(HOST, PORT, factory) reactor.run()