def registerSession(self,
sid,
initiator,
target,
callback,
meta=None,
block_size=None,
stanza_type='iq',
wait_for_result_when_send=True):
"""
Register bytestream session to wait for incoming connection.
"""
if isinstance(initiator, (str, unicode)):
initiator = internJID(initiator)
if isinstance(target, (str, unicode)):
target = internJID(target)
meta = {
'initiator': initiator,
'target': target,
'callback': callback,
'meta': meta,
'active': False,
'block_size': block_size,
'stanza_type': stanza_type,
'incoming_seq': 0,
'outgoing_seq': 0,
'wait_for_result_when_send': wait_for_result_when_send,
'is_outgoing': False,
'stanza': 'iq',
}
meta['transport'] = Transport(sid, meta, self.dispatcher,
self.send_interval)
self.sessions[sid] = meta
return meta
def registerSession(self, sid, initiator, target, callback, meta=None,
block_size=None, stanza_type='iq',
wait_for_result_when_send=True):
"""
Register bytestream session to wait for incoming connection.
"""
if isinstance(initiator, (str, unicode)):
initiator = internJID(initiator)
if isinstance(target, (str, unicode)):
target = internJID(target)
meta = {
'initiator': initiator,
'target': target,
'callback': callback,
'meta': meta,
'active': False,
'block_size': block_size,
'stanza_type': stanza_type,
'incoming_seq': 0,
'outgoing_seq': 0,
'wait_for_result_when_send': wait_for_result_when_send,
'is_outgoing': False,
'stanza': 'iq',
}
meta['transport'] = Transport(sid, meta, self.dispatcher,
self.send_interval)
self.sessions[sid] = meta
return meta
def leave_room(self, presence, room_jid, nickname):
"""
Sends 'unavailable'-type presence which leaves client from the room.
Fails if user not in room.
:param room_jid: JID of room-conference
:param nickname: string-type client's nickname in conference
"""
reciever = internJID(room_jid)
assert reciever.bare() in self.roster, 'not in room'
reciever.resource = nickname
presence = MyElement.makeFromElement(presence)
presence = Presence.createFromElement(presence)
presence.to = reciever
presence.from_ = self.dispatcher.myjid
presence.type_ = 'unavailable'
msg = ConnectPresence(parent=presence)
self.dispatcher.send(msg.parent)
del self.roster[reciever.bare()]
def enter_room(self, presence, room_jid, nickname):
"""
Sends 'available'-type presence which allows client to enter the room.
Fails if user already in room.
:param room_jid: JID of room-conference
:param nickname: string-type client's nickname in conference
:param status: string-type client's status message
"""
reciever = internJID(room_jid)
assert reciever.bare() not in self.roster, 'already in room'
reciever.resource = nickname
presence = MyElement.makeFromElement(presence)
presence = Presence.createFromElement(presence)
presence.to = reciever
presence.from_ = self.dispatcher.myjid
msg = ConnectPresence(parent=presence)
self.roster[reciever.bare()] = []
self.dispatcher.send(msg.parent)
def leave_room(self, presence, room_jid, nickname):
"""
Sends 'unavailable'-type presence which leaves client from the room.
Fails if user not in room.
:param room_jid: JID of room-conference
:param nickname: string-type client's nickname in conference
"""
reciever = internJID(room_jid)
assert reciever.bare() in self.roster, 'not in room'
reciever.resource = nickname
presence = MyElement.makeFromElement(presence)
presence = Presence.createFromElement(presence)
presence.to = reciever
presence.from_ = self.dispatcher.myjid
presence.type_ = 'unavailable'
msg = ConnectPresence(parent=presence)
self.dispatcher.send(msg.parent)
del self.roster[reciever.bare()]
def enter_room(self, presence, room_jid, nickname):
"""
Sends 'available'-type presence which allows client to enter the room.
Fails if user already in room.
:param room_jid: JID of room-conference
:param nickname: string-type client's nickname in conference
:param status: string-type client's status message
"""
reciever = internJID(room_jid)
assert reciever.bare() not in self.roster, 'already in room'
reciever.resource = nickname
presence = MyElement.makeFromElement(presence)
presence = Presence.createFromElement(presence)
presence.to = reciever
presence.from_ = self.dispatcher.myjid
msg = ConnectPresence(parent=presence)
self.roster[reciever.bare()] = []
self.dispatcher.send(msg.parent)
def availableHandler(self):
isConnected = False
name = u'%s/%s' % (self.guestJID, self.from_.resource)
jid = internJID(name)
if jid in self.host.pool.pool.keys():
client = self.host.pool.getClient(jid)
self.host.pool.addClient(jid, client)
client.sendStatus(self)
returnValue(EmptyStanza())
try:
client = j2jClient(self, self.host.dispatcher, name)
self.host.pool.addClient(self.from_, client)
yield client.connect(self.guestPass)
isConnected = True
except DNSLookupError:
raise errors.NotAcceptableException
except SASLAuthError:
raise errors.NotAuthorizedException
except TimeoutError:
raise errors.RemoteServerTimeoutException
except DuplicateClientsException:
pass
except Exception:
raise
finally:
if not isConnected:
self.host.pool.removeClient(self.from_)
returnValue(self.get_reply())
def __init__(self, myjid, keepalive_period=None):
"""
:param myjid: The jid of the component.
:param keepalive_period: The number of seconds between sending
of keepalives.
"""
self.myjid = internJID(myjid)
self.keepalive_period = keepalive_period
self.keepalive_send_task = task.LoopingCall(self.send_keepalive)
def __init__(self, reactor, version, config, cJid):
self.config = config
self.reactor = reactor
self.VERSION = version
self.cJid = internJID(cJid)
self.startTime = None
self.xmlstream = None
self.subscribed = SubscribedList(config)
self.wbase = WeatherBase()
self.online = []
def clean_body(self, value):
super(type(self), self).clean_body(value)
param = self.cmdpars.group(2)
if not param:
self.jid = self.host.client_jid
elif param == u'me':
self.jid = self.from_
else:
try:
self.jid = internJID(param)
except InvalidFormat:
raise WrongElement
return value
def set_affiliation(self, room_jid, jid, affiliation, reason=None):
"""
Sends query for changing user's affiliation to room jid.
Uses mostly of chat administrators.
:param room_jid: JID of room-conference
:param jid: JID of user
:param affiliation: value of new user's affiliation
:param reason: string-type argument with reason of affiliation changing
(default None)
"""
iq = Iq(type_='set', to=room_jid, from_=self.dispatcher.myjid)
i = UserItemInfo(jid=internJID(jid), affiliation=affiliation, reason=reason)
return makeAdminQuery(i, iq, self.dispatcher)
def set_affiliation(self, room_jid, jid, affiliation, reason=None):
"""
Sends query for changing user's affiliation to room jid.
Uses mostly of chat administrators.
:param room_jid: JID of room-conference
:param jid: JID of user
:param affiliation: value of new user's affiliation
:param reason: string-type argument with reason of affiliation changing
(default None)
"""
iq = Iq(type_='set', to=room_jid, from_=self.dispatcher.myjid)
i = UserItemInfo(jid=internJID(jid),
affiliation=affiliation,
reason=reason)
return makeAdminQuery(i, iq, self.dispatcher)
def to_python(self, value):
value = super(JidType, self).to_python(value)
if value is not None:
# XXX: Must raise ElementParseError if JID can't be converted
return internJID(value)
def onAuthenticated(self, xs):
self.myjid = internJID(unicode(xs.authenticator.jid))
self.dispatcher = Dispatcher(xs, self.myjid)
self.init()
self.deferred.callback(self)
self.deferred = None
def clean(self, value):
value = super(JidAttr, self).clean(value)
if value is not None or self.required:
return internJID(value)
self.dispatcher.send(presence)
version = '0.1'
configDefault = 'xmppbot.conf'
#read command-line's params
optparser = OptionParser(version="Xmpp bot version : %s" % version)
optparser.add_option('-c',
'--config',
metavar='FILE',
dest='configFile',
help="Read config from custom file")
(options, args) = optparser.parse_args()
configFile = options.configFile
#load configuration settings
config = ConfigParser.ConfigParser()
config.read(configFile if configFile else configDefault)
jid = config.get('connect', 'jid')
host = config.get('connect', 'host')
password = config.get('connect', 'password')
port = config.get('connect', 'port')
#connection to server
cl = Client(reactor, internJID(jid),
host, password, port)
reactor.run()
def test_internJID(self):
jidstring = 'user@host/resuorce'
test_jid = JID(jidstring)
self.assertEqual(jid.internJID(jidstring), test_jid)
self.assertEqual(jid.internJID(jidstring), test_jid)
def __init__(self, myjid):
self.myjid = internJID(myjid)
def to_python(self, value):
value = super(JidType, self).to_python(value)
if value is not None:
# XXX: Must raise ElementParseError if JID can't be converted
return internJID(value)
def __init__(self, myjid):
self.myjid = internJID(myjid)
def onAuthenticated(self, xs):
self.myjid = internJID(unicode(xs.authenticator.jid))
self.dispatcher = Dispatcher(xs, self.myjid)
self.init()
self.deferred.callback(self)
self.deferred = None
def test_topython(self):
jid = 'highway@hell'
jt = JidType()
self.assertEqual(internJID(jid), jt.to_python(jid))
self.assertEqual(None, jt.to_python(None))
