def __init__(self, host, port, jid, password):
self.host = host
self.port = port
factory = component.componentFactory(jid, password)
StreamManager.__init__(self, factory)
def __init__(self, host, port, jid, password):
self.host = host
self.port = port
factory = component.componentFactory(jid, password)
StreamManager.__init__(self, factory)
class DeferredClientFactory(XmlStreamFactoryMixin, protocol.ClientFactory):
protocol = xmlstream.XmlStream
def __init__(self, jid, password):
self.authenticator = client.XMPPAuthenticator(jid, password)
XmlStreamFactoryMixin.__init__(self, self.authenticator)
deferred = defer.Deferred()
self.deferred = deferred
self.addBootstrap(xmlstream.INIT_FAILED_EVENT, deferred.errback)
class ConnectionInitializedHandler(XMPPHandler):
def connectionInitialized(self):
deferred.callback(None)
self.streamManager = StreamManager(self)
self.addHandler(ConnectionInitializedHandler())
def clientConnectionFailed(self, connector, reason):
self.deferred.errback(reason)
def addHandler(self, handler):
"""
Add a subprotocol handler to the stream manager.
"""
self.streamManager.addHandler(handler)
def removeHandler(self, handler):
"""
Add a subprotocol handler to the stream manager.
"""
self.streamManager.removeHandler(handler)
def __init__(self, jid, password, host=None, port=5222):
self.domain = jid.host
self.host = host
self.port = port
factory = HybridClientFactory(jid, password)
StreamManager.__init__(self, factory)
def __init__(self, jid, password, host=None, port=5222):
self.jid = jid
self.domain = generic.prepareIDNName(jid.host)
self.host = host
self.port = port
factory = HybridClientFactory(jid, password)
StreamManager.__init__(self, factory)
def __init__(self, jid, password, host=None, port=5222, requireTLS=True):
self.jid = jid
self.domain = jid.host.encode('idna')
self.host = host
self.port = port
factory = HybridClientFactory(jid, password, requireTLS)
StreamManager.__init__(self, factory)
def __init__(self, reactor=None):
class DummyFactory(object):
def addBootstrap(self, event, fn):
pass
factory = DummyFactory()
StreamManager.__init__(self, factory, reactor)
self.stub = XmlStreamStub()
self._connected(self.stub.xmlstream)
self._authd(self.stub.xmlstream)
def __init__(self, reactor=None):
class DummyFactory(object):
def addBootstrap(self, event, fn):
pass
factory = DummyFactory()
StreamManager.__init__(self, factory, reactor)
self.stub = XmlStreamStub()
self._connected(self.stub.xmlstream)
self._authd(self.stub.xmlstream)
def _authd(self, xs):
"""
Called when the stream has been initialized.
Save the JID that we were assigned by the server, as the resource might
differ from the JID we asked for. This is stored on the authenticator
by its constituent initializers.
"""
self.jid = self.factory.authenticator.jid
StreamManager._authd(self, xs)
def _authd(self, xs):
"""
Called when the stream has been initialized.
Save the JID that we were assigned by the server, as the resource might
differ from the JID we asked for. This is stored on the authenticator
by its constituent initializers.
"""
self.jid = self.factory.authenticator.jid
StreamManager._authd(self, xs)
def _authd(self, xs):
old_send = xs.send
def send(obj):
if domish.IElement.providedBy(obj) and not obj.getAttribute("from"):
obj["from"] = self.xmlstream.thisEntity.full()
old_send(obj)
xs.send = send
StreamManager._authd(self, xs)
def _authd(self, xs):
old_send = xs.send
def send(obj):
if domish.IElement.providedBy(obj) and \
not obj.getAttribute('from'):
obj['from'] = self.xmlstream.thisEntity.full()
old_send(obj)
xs.send = send
StreamManager._authd(self, xs)
def __init__(self, host, port, domain, password, extra_handlers=[]):
self.host = host
self.port = port
self._state = None
factory = component.componentFactory(domain, password)
StreamManager.__init__(self, factory)
for handler in extra_handlers:
handler.setHandlerParent(self)
self._state = u'connecting'
zr = getUtility(IZopeReactor)
zr.reactor.callFromThread(self.connect)
def __init__(self, host, port, domain, password, extra_handlers=[]):
self.host = host
self.port = port
self._state = None
factory = component.componentFactory(domain, password)
StreamManager.__init__(self, factory)
for handler in extra_handlers:
handler.setHandlerParent(self)
self._state = u'connecting'
zr = getUtility(IZopeReactor)
zr.reactor.callFromThread(self.connect)
def __init__(self, jid, password):
self.authenticator = client.XMPPAuthenticator(jid, password)
XmlStreamFactoryMixin.__init__(self, self.authenticator)
deferred = defer.Deferred()
self.deferred = deferred
self.addBootstrap(xmlstream.INIT_FAILED_EVENT, deferred.errback)
class ConnectionInitializedHandler(XMPPHandler):
def connectionInitialized(self):
deferred.callback(None)
self.streamManager = StreamManager(self)
self.addHandler(ConnectionInitializedHandler())
class DeferredClientFactory(generic.DeferredXmlStreamFactory):
def __init__(self, jid, password):
authenticator = client.XMPPAuthenticator(jid, password)
generic.DeferredXmlStreamFactory.__init__(self, authenticator)
self.streamManager = StreamManager(self)
def addHandler(self, handler):
"""
Add a subprotocol handler to the stream manager.
"""
self.streamManager.addHandler(handler)
def removeHandler(self, handler):
"""
Add a subprotocol handler to the stream manager.
"""
self.streamManager.removeHandler(handler)
class DeferredClientFactory(generic.DeferredXmlStreamFactory):
def __init__(self, jid, password):
authenticator = client.XMPPAuthenticator(jid, password)
generic.DeferredXmlStreamFactory.__init__(self, authenticator)
self.streamManager = StreamManager(self)
def addHandler(self, handler):
"""
Add a subprotocol handler to the stream manager.
"""
self.streamManager.addHandler(handler)
def removeHandler(self, handler):
"""
Add a subprotocol handler to the stream manager.
"""
self.streamManager.removeHandler(handler)
def _authd(self, xs):
#Set JID
self.jid = self.xmlstream.thisEntity
#Patch send to always include from.
old_send = xs.send
def send(obj):
if domish.IElement.providedBy(obj) and \
not obj.getAttribute('from'):
obj['from'] = self.jid.full()
old_send(obj)
xs.send = send
StreamManager._authd(self, xs)
self._state = u'authenticated'
def _authd(self, xs):
#Set JID
self.jid = self.xmlstream.thisEntity
#Patch send to always include from.
old_send = xs.send
def send(obj):
if domish.IElement.providedBy(obj) and \
not obj.getAttribute('from'):
obj['from'] = self.jid.full()
old_send(obj)
xs.send = send
StreamManager._authd(self, xs)
self._state = u'authenticated'
def _authd(self, xs):
"""
Called when stream initialization has completed.
This replaces the C{send} method of the C{XmlStream} instance
that represents the current connection so that outgoing stanzas
always have a from attribute set to the JID of the component.
"""
old_send = xs.send
def send(obj):
if domish.IElement.providedBy(obj) and \
not obj.getAttribute('from'):
obj['from'] = self.xmlstream.thisEntity.full()
old_send(obj)
xs.send = send
StreamManager._authd(self, xs)
def _authd(self, xs):
"""
Called when stream initialization has completed.
This replaces the C{send} method of the C{XmlStream} instance
that represents the current connection so that outgoing stanzas
always have a from attribute set to the JID of the component.
"""
old_send = xs.send
def send(obj):
if domish.IElement.providedBy(obj) and \
not obj.getAttribute('from'):
obj['from'] = self.xmlstream.thisEntity.full()
old_send(obj)
xs.send = send
StreamManager._authd(self, xs)
def __init__(self, jid, password, extra_handlers=[],
host='localhost', port=5222):
jid.resource = randomResource()
self.jid = jid
self.domain = jid.host
self.host = host
self.port = port
self._state = None
self._connector = None
factory = client.HybridClientFactory(jid, password)
# Setup StreamManager
StreamManager.__init__(self, factory)
for handler in extra_handlers:
handler.setHandlerParent(self)
self._state = u'connecting'
zr = getUtility(IZopeReactor)
zr.reactor.callFromThread(self.connect)
def test_DiscoInfo(self):
factory = XmlStreamFactory()
sm = StreamManager(factory)
disco.DiscoHandler().setHandlerParent(sm)
DiscoResponder().setHandlerParent(sm)
xs = factory.buildProtocol(None)
output = []
xs.send = output.append
xs.connectionMade()
xs.dispatch(xs, "//event/stream/authd")
xs.dataReceived("<stream>")
xs.dataReceived("""<iq from='*****@*****.**' to='example.com'
type='get'>
<query xmlns='%s'/>
</iq>""" % NS_DISCO_INFO)
reply = output[0]
self.assertEqual(NS_DISCO_INFO, reply.query.uri)
self.assertEqual(NS_DISCO_INFO, reply.query.identity.uri)
self.assertEqual('dummy', reply.query.identity['category'])
self.assertEqual('generic', reply.query.identity['type'])
self.assertEqual('Generic Dummy Entity', reply.query.identity['name'])
self.assertEqual(NS_DISCO_INFO, reply.query.feature.uri)
self.assertEqual('jabber:iq:version', reply.query.feature['var'])
def __init__(self, jid, password):
authenticator = client.XMPPAuthenticator(jid, password)
generic.DeferredXmlStreamFactory.__init__(self, authenticator)
self.streamManager = StreamManager(self)
def _authd(self, xs):
#Save the JID that we were assigned by the server, as the resource
# might differ from the JID we asked for.
self.jid = self.factory.authenticator.jid
StreamManager._authd(self, xs)
self._state = u'authenticated'
def __init__(self, jid, password):
authenticator = client.XMPPAuthenticator(jid, password)
generic.DeferredXmlStreamFactory.__init__(self, authenticator)
self.streamManager = StreamManager(self)