def presence_match(
self, message): # frm=None, type=None, status=None, show=None):
frm, type, status, show, role, affiliation = message.frm, message.type, message.status, message.show, message.role, message.affiliation
#if self._frm !=None and frm != self._frm: return False
if self._type is not None and type != self._type:
return False
if self._status is not None and status != self._status:
return False
if self._show is not None and show != self._show:
return False
if self._role is not None and role != self._role:
return False
if self._affiliation is not None and affiliation != self._affiliation:
return False
if self._frm:
if not xmpp.JID(self._frm).getResource():
if self._frm != xmpp.JID(frm).getBareJID():
return False
else:
if self._frm != frm:
return False
return True
def testXMPPMessageMatchFalse(self):
xmpptemplate = xmpp.Message()
xmpptemplate.setFrom(xmpp.JID("sender1@host"))
xmpptemplate.setTo(xmpp.JID("recv1@host"))
message = xmpp.Message()
message.setFrom(xmpp.JID("sender1@host"))
message.setTo(xmpp.JID("recv2@host"))
mt = spade.Behaviour.MessageTemplate(xmpptemplate)
self.assertFalse(mt.match(message))
def invite(self, mess, args):
"""Invite a person to join the room. Works only if the person has added the bot as a friend, as of now."""
user = self.get_sender_username(mess)
if user in self.users:
self.send(
args,
'%s invited you to join %s. Say ",help" to see how to join.' %
(user, CHANNEL))
self.invited['%s@%s' % (xmpp.JID(args).getNode(),
xmpp.JID(args).getDomain())] = ''
self.log.info('%s invited %s.' % (user, args))
self.save_state()
self.message_queue.append('_%s invited %s_' %
(self.users[user], args))
def testXMPPIqMatchTrue(self):
xmpptemplate = xmpp.Iq()
xmpptemplate.setFrom(xmpp.JID("sender1@host"))
xmpptemplate.setTo(xmpp.JID("recv1@host"))
xmpptemplate.setType("set")
message = xmpp.Iq()
message.setFrom(xmpp.JID("sender1@host"))
message.setTo(xmpp.JID("recv1@host"))
message.setType("set")
mt = spade.Behaviour.MessageTemplate(xmpptemplate)
self.assertTrue(mt.match(message))
def park(self, vm_informations):
"""
Park a virtual machine
@type vm_informations: list
@param vm_informations: list of dict like {"uuid": x, "status": y, "parker": z)}
"""
vm_informations_cleaned = []
for vm_info in vm_informations:
if self.is_vm_parked(vm_info["uuid"]):
self.entity.log.error("VMPARKING: VM with UUID %s is already parked" % vm_info["uuid"])
continue
vm = self.entity.get_vm_by_uuid(vm_info["uuid"])
if not vm:
self.entity.log.error("VMPARKING: No virtual machine with UUID %s" % vm_info["uuid"])
continue
if not vm.domain:
self.entity.log.error("VMPARKING: VM with UUID %s cannot be parked because it is not defined" % vm_info["uuid"])
continue
vm_informations_cleaned.append(vm_info)
# Now, perform operations
for vm_info in vm_informations_cleaned:
vm = self.entity.get_vm_by_uuid(vm_info["uuid"])
if not vm.info()["state"] == 5:
vm.destroy()
domain = vm.xmldesc(mask_description=False)
vm_jid = xmpp.JID(domain.getTag("description").getData().split("::::")[0])
self.set_vms_status([vm_info])
self.entity.soft_free(vm_jid)
self.entity.push_change("vmparking", "parked")
class Bot:
def message_handler(connect_object, message_node):
command1 = str(unicode(message_node.getBody()).encode('utf-8'))
command2 = str(message_node.getFrom().getStripped())
#the fun begins from this place..
connect_object.send(xmpp.Message(command2, (k.respond(command1))))
b = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
a.write(str(b) + " " + command2 + " >>> " + k.respond(command1) + "\n")
jid = xmpp.JID(user)
connection = xmpp.Client(server)
connection.connect()
result = connection.auth(jid.getNode(), passwd)
connection.RegisterHandler('message', message_handler, "")
connection.RegisterHandler('presence', presence_handler, "")
connection.sendInitPresence()
press = xmpp.Presence()
press.setStatus(
"Hi from bot...i will chat with you and tell you new things you might like"
)
connection.send(press)
while (1):
connection.Process(1)
def delete(self, uuid, push=True):
"""
Delete a parked virtual machine
@type uuid: String
@param uuid: the UUID of a parked VM
@type push: Boolean
@param push: if False, do not push changes
"""
if not self.is_vm_already_parked(uuid):
raise Exception(
"There is no virtual machine parked with ticket %s" % ticket)
vm_item = self.get_vm_by_uuid_from_db(uuid)
self.remove_vm_from_db(uuid)
vmjid = xmpp.JID(
vm_item["domain"].getTag("description").getData().split("::::")[0])
vmfolder = "%s/%s" % (self.configuration.get(
"VIRTUALMACHINE", "vm_base_path"), vmjid.getNode())
if os.path.exists(vmfolder):
shutil.rmtree(vmfolder)
self.entity.get_plugin("xmppserver").users_unregister([vmjid])
if push:
self.entity.push_change("vmparking", "deleted")
self.entity.log.info(
"VMPARKING: successfully deleted %s from parking" % str(vmjid))
def unregister_vms(self, entries):
"""
Unregister a list of vms from central db.
@type entries: List
@param entries: list of vms
"""
# first, we extract jid so that the hypervisor can unregister them
uuids = []
for entry in entries:
uuids.append(entry["uuid"])
where_statement = "uuid = '"
where_statement += "' or uuid='".join(uuids)
where_statement += "'"
# list of vms which have been found in central db, including uuid and jid
cleaned_entries = self.read_vms("uuid,domain", where_statement)
for i in range(len(cleaned_entries)):
domain_xml = cleaned_entries[i]["domain"]
if domain_xml != "None":
domain = xmpp.simplexml.NodeBuilder(
data=cleaned_entries[i]["domain"]).getDom()
cleaned_entries[i]["jid"] = xmpp.JID(
domain.getTag("description").getData().split("::::")[0])
del (cleaned_entries[i]["domain"])
self.db_commit("delete from vms where uuid=:uuid", cleaned_entries)
return cleaned_entries
def start_bot():
if len(sys.argv) < 3:
print "Usage: start_bot.py [email protected] password"
else:
jid = xmpp.JID(sys.argv[1])
user, server, password = jid.getNode(), jid.getDomain(), sys.argv[2]
conn = xmpp.Client(server) #,debug=[])
conres = conn.connect()
if not conres:
print "Unable to connect to server %s!" % server
sys.exit(1)
if conres <> 'tls':
print "Warning: unable to estabilish secure connection - TLS failed!"
authres = conn.auth(user, password)
if not authres:
print "Unable to authorize on %s - check login/password." % server
sys.exit(1)
if authres <> 'sasl':
print "Warning: unable to perform SASL auth os %s. Old authentication method used!" % server
conn.RegisterHandler('message', messageCB)
conn.RegisterHandler('presence', presenceCB)
conn.sendInitPresence()
##conn.send(xmpp.protocol.Message('*****@*****.**','This is a automatic message'))
print "Bot started."
GoOn(conn)
def __init__(self, JID, Password):
""" Create a new bot. Connect to the server and log in. """
# connect...
jid = xmpp.JID(JID)
self.connection = xmpp.Client(jid.getDomain(), debug=[])
self.en_ml_db = None
result = self.connection.connect()
if result is None:
raise ConnectionError
# authorize
result = self.connection.auth(jid.getNode(), Password)
if result is None:
raise AuthorizationError
self.connection.RegisterHandler('presence', self.presenceHandler)
self.connection.RegisterHandler('message', self.messageHandler)
# ...become available
self.connection.sendInitPresence()
# presence
#self.connection.sendInitPresence(requestRoster=0)
try:
#search the dictionary in same directory of program
self.en_ml_db = DictDB("freedict-eng-mal")
except:
#retry in standard directory of dictd
self.en_ml_db = DictDB("/usr/share/dictd/freedict-eng-mal")
def __connect(self):
self._jid = xmpp.JID(self._settings.jid)
if not self._conn:
if not self._options.debug:
conn = xmpp.Client(self._jid.getDomain())
else:
conn = xmpp.Client(self._jid.getDomain(), debug=[])
res = conn.connect()
if not res:
logging.error("Unable to connect to server %s." %
self._jid.getDomain())
exit()
if res <> 'tls':
logging.warning("Unable to establish TLS connection.")
res = conn.auth(self._jid.getNode(), self._settings.password,
self._settings.chat_name)
if not res:
logging.error("Unable to authenticate this connection.")
exit()
if res <> 'sasl':
logging.warning("Unable to get SASL creditential for: %s." %
self.jid.getDomain())
conn.RegisterHandler('message', self.message_handler)
conn.RegisterHandler('presence', self.presence_handler)
conn.sendInitPresence()
self.roster = conn.Roster.getRoster()
self._conn = conn
if hasattr(self._settings, 'default_status'):
self._conn.send(
xmpp.Presence(status=self._settings.default_status))
if hasattr(self._settings, 'groupchat'): self.__join_muc()
def __init__(self, username, password, res=None):
"""Initializes the jabber bot and sets up commands."""
self.__username = username
self.__password = password
self.__finished = False
self.__status = None
self.__seen = {}
self.__threads = {}
self.log = logging.getLogger(__name__)
self.jid = xmpp.JID(self.__username)
self.res = (res or self.__class__.__name__)
self.conn = None
self.roster = None
self.commands = {}
self.xmpp_debug = []
self.reconnecting = False
self.ignore_offline = False
self.on_connect = no_fn
self.on_reconnect = no_fn
self.on_disconnect = no_fn
for name, value in inspect.getmembers(self):
if (inspect.ismethod(value)
and getattr(value, '_jabberbot_command', False)):
name = getattr(value, '_jabberbot_command_name')
self.log.debug('Registered command: %s' % name)
self.commands[name] = value
def _init(self, debug):
self._inbox = Queue(self.store.xmpp.inbox, self.log)
self._outbox = Queue(self.store.xmpp[self.config["xmpp"]["user"]],
self.log)
#self._inbox.clear()
self._outbox.timeout(-1)
JID = xmpp.JID(self.user)
self.connection = xmpp.Client(JID.getDomain(), debug=debug)
server = self.config["xmpp"]["server"]
port = int(self.config["xmpp"]["port"])
if self.connection.connect((server, port)) == '':
self.log.error('Cannot connect to server %s port %d' %
(server, port))
sys.exit(1)
if self.connection.auth(JID.getNode(), self.token,
self.user + '-') == None:
self.log.error('Authentication %s failed!' % self.user)
sys.exit(1)
self.connection.RegisterDisconnectHandler(
self.connection.reconnectAndReauth())
self.connection.RegisterHandler('message', self.receive)
self.connection.getRoster()
self.connection.sendInitPresence()
def is_bot_owner(self, room, nick):
# проверка на уровень доступа овнера
#FIXME: может не работать на полностью анонимных серверах
if not self.in_roster(room, nick): return False
jid = self.roster[room][nick][ROSTER_JID]
if jid != None: jid = xmpp.JID(jid).getStripped().lower()
return jid in self.configuration['bot_owners']
def connect(self):
server = "gmail.com"
jid = xmpp.JID(self.user)
self.connection = xmpp.Client(server, debug=[])
print "Connecting.."
server = ('talk.google.com', 5223)
if not self.connection.connect(server):
self.emit(
QtCore.SIGNAL("error"),
"<b>Connection Error!</b><br>Check your internet connection")
return False
print "Connected!"
result = self.connection.auth(jid.getNode(), self.password,
self.appResource)
if not result:
self.emit(
QtCore.SIGNAL("error"),
"<b>Authentication Error!</b><br>Check your username and password"
)
return False
self.connection.RegisterHandler('message', self.receiveHandler)
self.connection.RegisterHandler('presence', self.presenceHandler)
self.connection.sendInitPresence()
self.setStatus("Scribbling in Colors")
self.roster = self.connection.getRoster()
self.emit(QtCore.SIGNAL("connected"), True)
return True
def _initial_vars(self, *args, **kwargs):
super(XMPP_Client, self)._initial_vars(*args, **kwargs)
self._xmpp_id = kwargs.get('id', None)
self._password = kwargs.get('password', None)
self._server = kwargs.get('server', None)
self._port = kwargs.get('port', None)
if not self._xmpp:
self._logger.info(
'Connecting to server for id:{id} ({server})'.format(
id=self._xmpp_id,
server=self._server,
))
status = None
jid = xmpp.JID(self._xmpp_id)
self._xmpp = xmpp.Client(jid.getDomain())
self.connect()
self._logger.info("Connection Result: {0}".format(status))
result = self._xmpp.auth(
re.match('(.*)\@.*', self._xmpp_id).group(1), self._password,
'TESTING')
#self._xmpp.sendInitPresence()
self._logger.debug('Processing' + str(result))
else:
self._logger.debug('Here twice?')
def unpark(self, vm_informations):
"""
Unpark virtual machine
@type vm_informations: list
@param vm_informations: list of dict like {"uuid": x, "status": y, "start": True|False, "parker": z}
"""
vm_informations_cleaned = []
# First, check if everything is correct and cleanup bad items
for vm_info in vm_informations:
if self.is_vm_parked(vm_info["uuid"]):
vm_informations_cleaned.append(vm_info)
else:
self.entity.log.error("VMPARKING: There is no virtual machine parked with uuid %s" % vm_info["uuid"])
# Now, perform operations
for vm_info in vm_informations_cleaned:
vm_item = self.get_vm_by_uuid_from_db(vm_info["uuid"])
domain = vm_item["domain"]
ret = str(domain).replace('xmlns=\"archipel:hypervisor:vmparking\"', '')
domain = xmpp.simplexml.NodeBuilder(data=ret).getDom()
vmjid = domain.getTag("description").getData().split("::::")[0]
vmpass = domain.getTag("description").getData().split("::::")[1]
vmname = domain.getTag("name").getData()
vm_thread = self.entity.soft_alloc(xmpp.JID(vmjid), vmname, vmpass, start=False, organizationInfo=self.entity.vcard_infos)
vm = vm_thread.get_instance()
vm.register_hook("HOOK_ARCHIPELENTITY_XMPP_AUTHENTICATED", method=vm.define_hook, user_info=domain, oneshot=True)
if vm_info["start"]:
vm.register_hook("HOOK_ARCHIPELENTITY_XMPP_AUTHENTICATED", method=vm.control_create_hook, oneshot=True)
vm_thread.start()
self.set_vms_status([vm_info])
self.entity.push_change("vmparking", "unparked")
self.entity.log.info("VMPARKING: successfully unparked %s" % str(vmjid))
def start(self, gmail_account, password):
jid = xmpp.JID(gmail_account)
user, server, password = jid.getNode(), jid.getDomain(), password
self.conn = xmpp.Client(server, debug=self.debug)
#talk.google.com
conres = self.conn.connect(server=(self.server_host, self.server_port))
if not conres:
print "Unable to connect to server %s!" % server
sys.exit(1)
if conres <> 'tls':
print "Warning: unable to estabilish secure connection - TLS failed!"
authres = self.conn.auth(user, password)
if not authres:
print "Unable to authorize on %s - Please check your name/password." % server
sys.exit(1)
if authres <> "sasl":
print "Warning: unable to perform SASL auth os %s. Old authentication method used!" % server
self.conn.RegisterHandler("message", self.controller)
self.conn.RegisterHandler('presence', self.presenceHandler)
self.conn.sendInitPresence()
self.setState(self.show, self.status)
print "Bot started."
self.GoOn()
def delete(self, vm_uuids):
"""
Delete a parked virtual machine
@type vm_uuids: list
@param uuid: list of dic like {"uuid": x}
"""
vm_jids = []
# first, check there is no problems
for vm_uuid in vm_uuids:
if not self.is_vm_parked(vm_uuid["uuid"]):
raise Exception("There is no virtual machine parked with uuid %s" % vm_uuid["uuid"])
vm_item = self.get_vm_by_uuid_from_db(vm_uuid["uuid"])
vm_jids.append(xmpp.JID(vm_item["domain"].getTag("description").getData().split("::::")[0]))
# Update DB and Push
self.unregister_vms_from_db(vm_uuids)
self.entity.push_change("vmparking", "deleted")
# Then perfom cleanup operations
for vm_jid in vm_jids:
vmfolder = "%s/%s" % (self.configuration.get("VIRTUALMACHINE", "vm_base_path"), vm_jid.getNode())
if os.path.exists(vmfolder):
shutil.rmtree(vmfolder)
# And remove the XMPP account
self.entity.get_plugin("xmppserver").users_unregister(vm_jids)
self.entity.log.info("VMPARKING: successfully deleted %s from parking" % str(vm_jids))
def __init__(self, username, password, res=None, debug=False):
"""Initializes the jabber bot and sets up commands."""
self.__debug = debug
self.log = logging.getLogger(__name__)
self.__username = username
self.__password = password
self.jid = xmpp.JID(self.__username)
self.res = (res or self.__class__.__name__)
self.conn = None
self.__finished = False
self.__exitcode = 0
self.__show = None
self.__status = None
self.__seen = {}
self.__threads = {}
self.commands = {}
for name, value in inspect.getmembers(self):
if inspect.ismethod(value) and getattr(value, '_jabberbot_command', False):
name = getattr(value, '_jabberbot_command_name')
if self.__debug:
self.log.debug('Registered command: %s' % name)
self.commands[name] = value
self.roster = None
def is_registered(jid, spool=conf.profile_dir):
bare_jid = xmpp.JID(jid).getStripped()
file = os.path.join(spool, bare_jid + '.xdb')
if os.path.exists(file) and os.path.isfile(file):
return True
else:
return False
def send(self, mess):
"""send a message to the specified recipient"""
(text, to) = (mess.get_text(), mess.get_to())
if mess.get_emote():
text = '/me ' + mess.get_text()
mess = self.__build_message(text)
mess.setType('chat')
if isinstance(to, Room):
mess.setType('groupchat')
to = to.get_name()
mess.setTo(xmpp.JID(str(to)))
# outer try block catches disconnected from _sock.recv() and conn.send()
try:
# check if the socket is dead (send doesn't do that, so we'll recv)
# if recv() raises an exception it timed out and everything is fine
# if it returns an empty string the socket is dead
try:
if not self.conn.Connection._sock.recv(1, socket.MSG_PEEK):
raise IOError
except socket.error as e:
pass
# actually try to send the message
self.conn.send(mess)
except IOError:
self.disconnected(self.ConnectFailure)
def connect(self):
self.disconnected = False
jid = xmpp.JID(self.login)
user, server, password = jid.getNode(), jid.getDomain(), self.password
self.conn = xmpp.Client(server, debug=[])
conres = self.conn.connect(server=(self.server_host, self.server_port))
if not conres:
print "Unable to connect to server %s!" % server
sys.exit(1)
if conres <> 'tls':
print "Warning: unable to estabilish secure connection - TLS failed!"
authres = self.conn.auth(user, password, "laptop")
if not authres:
print "Unable to authorize on %s - Plsese check your name/password." % server
sys.exit(1)
if authres <> "sasl":
print "Warning: unable to perform SASL auth os %s. Old authentication method used!" % server
self.conn.RegisterHandler("message", self.controller)
self.conn.RegisterHandler('presence', self.presenceHandler)
self.conn.RegisterDisconnectHandler(self.on_disconnect)
self.conn.sendInitPresence()
self.setState(self.show, self.status)
if self.timer:
try:
self.timer.cancel()
except:
pass
self.timer = threading.Timer(600, self.ping)
self.timer.start()
def messageCB(con, msg):
msgtype = msg.getType()
body = msg.getBody()
if body != None:
body = body.strip()
fromjid = msg.getFrom()
command = ''
parameters = ''
if body and string.split(body):
command = string.lower(string.split(body)[0])
if body.count(' '):
parameters = body[(body.find(' ') + 1):]
if not msg.timestamp:
if msgtype == 'groupchat':
call_message_handlers('public', [fromjid, fromjid.getStripped(), fromjid.getResource()], body)
if command in COMMANDS:
call_command_handlers(command, 'public', [fromjid, fromjid.getStripped(), fromjid.getResource()], parameters)
else:
call_message_handlers('private', [fromjid, fromjid.getStripped(), fromjid.getResource()], body)
if command in COMMANDS:
call_command_handlers(command, 'private', [fromjid, fromjid.getStripped(), fromjid.getResource()], parameters)
for x_node in msg.getTags('x', {}, 'jabber:x:conference'):
inviter_jid = None
muc_inviter_tag = msg.getTag('x', {}, 'http://jabber.org/protocol/muc#user')
if muc_inviter_tag:
if muc_inviter_tag.getTag('invite'):
if muc_inviter_tag.getTag('invite').getAttr('from'):
inviter_jid = xmpp.JID(muc_inviter_tag.getTag('invite').getAttr('from'))
if not inviter_jid:
inviter_jid = fromjid
call_groupchat_invite_handlers([inviter_jid, inviter_jid.getStripped(), inviter_jid.getResource()], x_node.getAttr('jid'), body)
def command_remember(bot, room, nick, access_level, parameters, message):
try: (term, definition) = parameters.split(' ', 1)
except: return "Expected: <term> <definition>"
jid = bot.roster[room][nick][ROSTER_JID]
if jid != None: jid = xmpp.JID(jid).getStripped().lower()
for c in term:
if ord(c) > 127 or ord(c)<32:
return "Bad term, don't use unicode."
if term == '' or term == ':':
return "The term is empty."
# remove : added by common mistake
if term[-1] == ':': term = term[:-1]
term_key = term.lower()
existent_term = getterm(bot, room, term_key)
if existent_term and access_level < LEVEL_ADMIN:
if existent_term['jid'] != jid:
return "You can't redefine %s."%(term)
if access_level < LEVEL_ADMIN:
definition +=' (added by '+nick+')'
termdic = {
'def': definition,
'jid': jid,
'time': time.time(),
}
setterm(bot, room, term_key, termdic)
return "I know %s!"%(term)
def _unpark_callback(vm_items):
vm_information_by_uuid = {}
for vm_info in vm_information:
vm_information_by_uuid[vm_info["uuid"]] = vm_info
for vm_item in vm_items:
vm_info = vm_information_by_uuid[vm_item["uuid"]]
domain = vm_item["domain"]
ret = str(domain).replace('xmlns=\"archipel:hypervisor:vmparking\"', '')
domain = xmpp.simplexml.NodeBuilder(data=ret).getDom()
vmjid = domain.getTag("description").getData().split("::::")[0]
vmpass = domain.getTag("description").getData().split("::::")[1]
vmname = domain.getTag("name").getData()
self.entity.log.debug("VMPARKING: about to create vm thread")
vm_thread = self.entity.soft_alloc(xmpp.JID(vmjid), vmname, vmpass, start=False, organization_info=self.entity.vcard_infos)
vm = vm_thread.get_instance()
vm.register_hook("HOOK_ARCHIPELENTITY_XMPP_AUTHENTICATED", method=vm.define_hook, user_info=domain, oneshot=True)
if vm_info["start"]:
vm.register_hook("HOOK_ARCHIPELENTITY_XMPP_AUTHENTICATED", method=vm.control_create_hook, oneshot=True)
vm_thread.start()
self.entity.push_change("vmparking", "unparked")
self.entity.log.info("VMPARKING: successfully unparked %s" % str(vmjid))
def __init__(self):
try:
with open(secrets_filename, "r") as f:
data = f.read()
except:
err = "Error processing {} - make sure to fill in {} and reading the " + \
"instructions in discover_gchat_id.py".format(secrets_filename, secrets_filename)
with open(secrets_filename, "w") as f:
f.write(document)
raise Exception(err)
try:
conf = yaml.load(data)
self.automation_user = conf["automation_user"]
self.automation_password = conf["automation_password"]
self.automation_server = conf["automation_server"]
self.automation_port = conf["automation_port"]
self.destination_user = conf["destination_user"]
except:
raise Exception("Error parsing {}!".format(secrets_filename))
if self.automation_user is None or self.automation_password is None or self.automation_server is None or \
self.automation_port is None or self.destination_user is None:
raise Exception(
"Error parsing {} - not all fields have been filled in!".
format(secrets_filename))
server = (self.automation_server, self.automation_port)
jid = xmpp.JID(self.automation_user)
self.connection = xmpp.Client(jid.getDomain(), debug=[])
self.connection.connect(server)
result = self.connection.auth(jid.getNode(), self.automation_password)
self.connection.sendInitPresence()
def retract_success(resp, user_info):
if resp.getType() == "result":
domain = vm_item.getTag("virtualmachine").getTag("domain")
ret = str(domain).replace(
'xmlns=\"archipel:hypervisor:vmparking\"', '')
domain = xmpp.simplexml.NodeBuilder(data=ret).getDom()
vmjid = domain.getTag("description").getData().split("::::")[0]
vmpass = domain.getTag("description").getData().split(
"::::")[1]
vmname = domain.getTag("name").getData()
vm_thread = self.entity.soft_alloc(xmpp.JID(vmjid),
vmname,
vmpass,
start=False)
vm = vm_thread.get_instance()
vm.register_hook("HOOK_ARCHIPELENTITY_XMPP_AUTHENTICATED",
method=vm.define_hook,
user_info=domain,
oneshot=True)
if start:
vm.register_hook("HOOK_ARCHIPELENTITY_XMPP_AUTHENTICATED",
method=vm.control_create_hook,
oneshot=True)
vm_thread.start()
self.inhibit_next_general_push = True
self.entity.push_change("vmparking", "unparked")
self.entity.log.info("VMPARKING: successfully unparked %s" %
str(vmjid))
else:
self.inhibit_next_general_push = True
self.entity.push_change("vmparking",
"cannot-unpark",
content_node=resp)
self.entity.log.error("VMPARKING: cannot unpark: %s" %
str(resp))
def create_parked(self, uuid, xmldesc, parker_jid, push=True):
"""
Creates a VM directly into the parking.
@type uuid: String
@param uuid: The UUID of the VM to create and park
@type xmldesc: xmpp.simplexml.Node
@param xmldesc: The XML desc to park. The UUID inside must the same than UUID parameter
@type parker_jid: xmpp.protocol.JID
@param parker_jid: the JID of the parker
"""
if self.is_vm_already_parked(uuid):
raise Exception("VM with UUID %s is already parked" % uuid)
vm = self.entity.get_vm_by_uuid(uuid)
if vm:
raise Exception("There is already a VM with UUID %s" % uuid)
if xmldesc.getTag("description"):
raise Exception(
"You cannot park a VM XML with a <description/> tag. Please remove it"
)
password = ''.join(
[random.choice(string.letters + string.digits) for i in range(32)])
xmldesc.addChild("description").setData(
"%s@%s::::%s" % (uuid, self.entity.jid.getDomain(), password))
vm_jid = xmpp.JID(
xmldesc.getTag("description").getData().split("::::")[0])
self.add_vm_into_db(uuid, parker_jid, xmldesc)
self.entity.log.info(
"VMPARKING: New virtual machine %s as been parked" % uuid)
if push:
self.entity.push_change("vmparking", "parked")
class CollaborativeMicroblogging:
def message_handler(connect_object, message_node):
command1 = str(unicode(message_node.getBody()).encode('utf-8'))
command2 = str(message_node.getFrom().getStripped())
c3 = command2.replace("@", " [at] ")
c4 = c3.replace(".", " [dot] ")
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
api.update_status(command1)
connect_object.send(
xmpp.Message(message_node.getFrom(),
("Posted your message on Twitter " + command1)))
jid = xmpp.JID(user)
connection = xmpp.Client(server)
connection.connect()
result = connection.auth(jid.getNode(), passwd)
connection.RegisterHandler('message', message_handler, "")
connection.sendInitPresence()
press = xmpp.Presence()
press.setStatus("Hi from Collaborative Microblogging App")
connection.send(press)
while (1):
connection.Process(1)
