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 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 __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 _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 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 __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()
