def template_remove(argv):
'''
remove template image and data in database
must be called at nfs server*
'''
templateID = argv[0]
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"SELECT `fileName` FROM `templates` WHERE `activity`=0 AND `templateID`=%s"
% (templateID))
tmp = cursor.fetchone()
if tmp == None:
return 'template not found or template is busy'
fileName = tmp[0]
cursor.execute("DELETE FROM `templates` WHERE `templateID`=%s" %
(templateID))
db.close()
try:
os.remove(setting.TEMPLATE_PATH + fileName)
except:
return "cannot remove image file completely"
return "OK"
def template_remove(taskID, detail):
#get parameter
templateID = detail['templateID']
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute("SELECT `guestID` FROM `guests` WHERE `templateID`=%s" %
(str(detail['templateID'])))
if cursor.fetchone() != None:
return 'There are guests that use this template'
cursor.execute("SELECT `IPAddress` FROM `hosts` WHERE `isStorageHolder`=1")
storageHolder = cursor.fetchone()[0]
db.close()
result = connection.socketCall(str(storageHolder), setting.LOCAL_PORT,
'template_remove', [str(templateID)])
if result != 'OK':
return result
content = ''
if not shortcut.storeFinishMessage(taskID, content):
return "cannot storeFinishMessage"
return "OK"
def clone_ca(argv):
'''
only real ca can do this method
(source of ca migration)
'''
targetHostIP = argv[0]
mode = argv[1]
cakeyString = open(setting.CA_PATH + 'cakey.pem', 'r').read()
cacertString = open(setting.CA_PATH + 'cacert.pem', 'r').read()
result = connection.socketCall(targetHostIP, setting.LOCAL_PORT,
"you_are_next_ca",
[cakeyString, cacertString, mode])
if mode == 'migrate':
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute("UPDATE `hosts` SET `isCA`=0 WHERE `IPAddress`='%s';" %
(str(network.getMyIPAddr())))
db.close()
elif mode == 'makeSlave':
pass
return result
def you_are_next_ca(argv):
'''
destination of ca migration
'''
cakeyString = argv[0]
cacertString = argv[1]
mode = argv[2]
result = subprocess.Popen(shlex.split("mkdir -p %s" % (setting.CA_PATH)),
stdout=subprocess.PIPE)
result.wait()
cakeyFile = open(setting.CA_PATH + 'cakey.pem', 'w')
cakeyFile.write(cakeyString)
cakeyFile.close()
cacertFile = open(setting.CA_PATH + 'cacert.pem', 'w')
cacertFile.write(cacertString)
cacertFile.close()
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
if mode == 'migrate':
cursor.execute("UPDATE `hosts` SET `isCA`=1 WHERE `IPAddress`='%s';" %
(str(network.getMyIPAddr())))
elif mode == 'makeSlave':
cursor.execute("UPDATE `hosts` SET `isCA`=2 WHERE `IPAddress`='%s';" %
(str(network.getMyIPAddr())))
db.close()
return "OK"
def index(self, guestID, guestName):
try:
if not general.isGoodName(guestName):
return 'Name ' + guestName + ' cannot be a guestName, please choose the new one.'
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"SELECT `guestID` FROM `guests` WHERE `guestID`=%s" %
(guestID))
if cursor.fetchone() == None:
db.close()
return shortcut.response('error', '', 'no guest found')
if guestName == '':
db.close()
return shortcut.response('error', '', 'invalid guest name')
cursor.execute(
"UPDATE `guests` SET `guestName`='%s' WHERE `guestID`=%s" %
(guestName, guestID))
db.close()
except:
return shortcut.response(
'error', '', MySQLdb.escape_string(traceback.format_exc()))
content = ''
return shortcut.response('success', content,
'Your guest has been renamed')
def index(self, guestIP, targetHostID=None):
#resolve for guestID
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"SELECT `guestID` FROM `guests` WHERE `IPAddress`='%s' " %
(guestIP))
guestID = cursor.fetchone()
db.close()
if guestID != None:
guestID = guestID[0]
else:
return shortcut.response('error', '', 'guestIP not found')
detail = {'command': 'guest_start', 'guestID': guestID}
if targetHostID != None:
detail['targetHostID'] = targetHostID
taskID = queue.enqueue(detail)
return shortcut.responseTaskID(taskID)
def index(self, guestID):
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
#find hostIPAddress, UUID
cursor.execute('''SELECT `hosts`.`IPAddress` , `lastUUID`
FROM `hosts` INNER JOIN `guests`
ON `hosts`.`hostID`=`guests`.`lastHostID`
AND `guests`.`status`=1 AND `guests`.`activity`=0
AND `guests`.`guestID`=%s;''' % (guestID))
targetData = cursor.fetchone()
db.close()
if targetData == None:
return shortcut.response(
'error', '',
'Invalid guestID or Machine was closed or doing activity')
hostIP = targetData[0]
UUID = targetData[1]
result = connection.socketCall(hostIP, setting.LOCAL_PORT,
'guest_send_reboot_signal', [UUID])
if result != "OK":
return shortcut.response('error', '', result)
#no content
return shortcut.response(
'success', '', 'Reboot signal was sending to the guest.')
def are_you_running_dhcpd(argv):
'''
if i am running dhcpd, i will reply "yes"
'''
myIP = network.getMyIPAddr()
globalControllerIP = cacheFile.getGlobalControllerIP()
if globalControllerIP == None:
return 'no'
if str(myIP) != str(globalControllerIP):
return 'no'
else:
try:
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"SELECT `IPAddress` FROM `hosts` WHERE `isGlobalController`=1")
result = cursor.fetchone()
db.close()
if result == None or result[0] != str(myIP):
return 'no'
else:
return 'yes'
except MySQLdb.Error, e:
return 'no'
def have_this_mac(argv):
'''
this will reply weather that mac address is in cloud system or not
'''
mac = argv[0]
infoHost = cacheFile.getDatabaseIP()
if infoHost == None:
return 'no'
try:
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute('''SELECT * FROM
(SELECT `MACAddress` FROM `hosts`
UNION
SELECT `MACAddress` FROM `guests`) as `tmp` WHERE `MACAddress`='%s'
''' % string.upper(mac))
if cursor.fetchone() == None:
db.close()
return 'no'
else:
db.close()
return 'yes'
except MySQLdb.Error, e:
return 'no'
def index(self, taskID):
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
'''SELECT `opcode`,`detail`,`status`,`finishStatus`,`finishMessage`,`createTimestamp`,`finishTimestamp`
FROM `tasks` WHERE `taskID`=%s
''' % (str(taskID)))
db.close()
taskData = cursor.fetchone()
if taskData == None:
return shortcut.response('error', '', 'taskID not found')
templateString = open(setting.MAIN_PATH +
'webapi/template/task_poll.xml').read()
content = templateString % {
'taskID': str(taskID),
'opcode': str(taskData[0]),
'detail': taskData[1],
'status': str(taskData[2]),
'finishStatus': str(taskData[3]),
'finishMessage': taskData[4],
'createTimestamp': taskData[5],
'finishTimestamp': taskData[6]
}
return shortcut.response('success', content)
def broadcastNewSlaveInformationServer(
slaveHostIP,
masterHostIP=None): #if leave slaveHostIP='-' means slave was delete
'''
can be call at any host
tell every active host to keep slave ip in file
'''
if masterHostIP == None:
masterHostIP = cacheFile.getDatabaseIP()
print "slaveHostIP:", slaveHostIP
db = MySQLdb.connect(masterHostIP, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute("SELECT `IPAddress` FROM `hosts` WHERE `status`=1 ;")
activeHost = cursor.fetchall()
db.close()
dataString = json.dumps({'slaveDB': str(slaveHostIP)})
for host in activeHost:
result = connection.socketCall(host[0], setting.LOCAL_PORT,
'update_cloud_info',
['{socket_connection}', dataString])
return True
def migrate(targetHostIP=None):
'''
only move 2 file from oldCA to newCA
and update database
'''
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute('''SELECT
`IPAddress`
FROM `hosts` WHERE `isCA`=1''')
oldCAData = cursor.fetchone()
db.close()
if oldCAData == None:
print 'Old CA not found'
return False
oldCAIP = oldCAData[0]
result = connection.socketCall(oldCAIP, setting.LOCAL_PORT, "clone_ca",
[targetHostIP, 'migrate'])
if result != "OK":
return False
return True
def promote(slaveHostIP=None):
'''
only update in database
'''
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
if slaveHostIP != None:
condition = " AND `IPAddress`='%s'" % (str(slaveHostIP))
else:
condition = ''
cursor.execute('''SELECT
`IPAddress`
FROM `hosts` WHERE `isCA`=2 %s;''' % (condition))
hostData = cursor.fetchone()
if hostData == None:
print 'active slave CA not found!'
return False
slaveHostIP = hostData[0]
cursor.execute("UPDATE `hosts` SET `isCA`=1 WHERE `IPAddress`='%s';" %
(slaveHostIP))
db.close()
return True
def guest_shutoff(taskID, detail):
#get parameter
guestID = detail['guestID']
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
#find hostIPAddress, UUID
cursor.execute('''SELECT `hosts`.`IPAddress` , `lastUUID`
FROM `hosts` INNER JOIN `guests`
ON `hosts`.`hostID`=`guests`.`lastHostID`
AND `guests`.`status`=1 AND `guests`.`activity`=0
AND `guests`.`guestID`=%s;''' % (guestID))
targetData = cursor.fetchone()
db.close()
if targetData == None:
return 'Invalid guestID or cannot force-off in this status'
hostIP = targetData[0]
UUID = targetData[1]
result = connection.socketCall(hostIP, setting.LOCAL_PORT,
'guest_force_off', [str(guestID), UUID])
if result != 'OK':
return result
content = ""
if not shortcut.storeFinishMessage(taskID, content):
return "cannot storeFinishMessage"
return "OK"
def destroy_slave_host_info(argv):
'''
dest = slave only
'''
myIP = network.getMyIPAddr()
db = MySQLdb.connect("localhost", "root", setting.DB_ROOT_PASSWORD)
cursor = db.cursor()
cursor.execute("SLAVE STOP;")
cursor.execute("DROP DATABASE IF EXISTS %s" %
(setting.DB_NAME)) #this line was added later
db.close()
dbController.stop()
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"UPDATE `hosts` SET `isInformationServer`=0 WHERE `IPAddress`='%s'" %
(str(myIP)))
db.close()
dbController.broadcastNewSlaveInformationServer('-')
return 'OK'
def ca_migrate(taskID, detail):
#get parameter
targetHostID = detail['targetHostID']
#start work
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute('''SELECT
`IPAddress`
FROM `hosts` WHERE `hostID`=%s AND `status`=1''' % (str(targetHostID)))
targetHostData = cursor.fetchone()
db.close()
if targetHostData == None:
return 'targetHostID not found or targetHostID is turned off'
targetHostIP = targetHostData[0]
success = caService.migrate(targetHostIP)
if not success:
return 'ca migration error'
return 'OK'
def index(self,templateID=None):
infoHost=cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD, setting.DB_NAME )
cursor = db.cursor()
if templateID==None:
conditionString="";
else:
conditionString="WHERE `templateID`=%s"%(str(templateID))
cursor.execute('''SELECT
`templateID`, `OS`,`size`,`description`,`minimumMemory`,`maximumMemory`,`activity`
FROM `templates`'''+conditionString+";")
table=cursor.fetchall()
db.close()
templateString=open(setting.MAIN_PATH+'webapi/template/template_getInfo.xml').read()
result=''
for row in table:
templateDict={
'templateID':str(row[0]),
'OS':str(row[1]),
'size':str(row[2]),
'description':str(row[3]),
'minimumMemory':str(row[4]),
'maximumMemory':str(row[5]),
'activity':str(row[6])
}
result+=templateString%templateDict
return shortcut.response('success', result)
def index(self):
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute("SELECT `key`,`value` FROM `cloud_variables`")
cloudData = cursor.fetchall()
valDict = {}
for element in cloudData:
valDict[element[0]] = element[1]
cursor.execute("SELECT `IPAddress` FROM `guest_ip_pool`")
poolData = cursor.fetchall()
ipList = []
for element in poolData:
ipList.append(element[0])
valDict['guestIPPoolList'] = ','.join(ipList)
templateString = open(setting.MAIN_PATH +
'webapi/template/cloud_getInfo.xml').read()
content = templateString % valDict
db.close()
return shortcut.response('success', content)
def run(self):
global threadResult
try:
#shutil.copy2(setting.IMAGE_PATH+self.sourceFileName,setting.TEMPLATE_PATH+self.targetFileName)
result = subprocess.Popen(
shlex.split("qemu-img convert %s -O qcow2 %s" %
(setting.IMAGE_PATH + self.sourceFileName,
setting.TEMPLATE_PATH + self.targetFileName)))
result.wait()
result = subprocess.Popen(
shlex.split("chmod 777 %s" %
(setting.TEMPLATE_PATH + self.targetFileName)))
result.wait()
activity = 0
print "Create new template success"
threadResult = "OK"
except:
threadResult = MySQLdb.escape_string(traceback.format_exc())
activity = -1
print "Create new template error"
#finish and tell database that you finish
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
'''UPDATE `templates` SET `activity`=%s WHERE `templateID`=%s''' %
(str(activity), self.templateID))
db.close()
def index(self, hostID=None):
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
if hostID == None:
conditionString = ""
else:
conditionString = "WHERE `hostID`=%s" % (str(hostID))
cursor.execute('''SELECT
`hostID`, `IPAddress`
FROM `hosts`''' + conditionString + ";")
table = cursor.fetchall()
if len(table) == 0:
return shortcut.response('error', '', 'hostID not found')
if hostID == None:
argv = []
else:
argv = [str(table[0][1])] #IPAddr
data = connection.socketCall("localhost", setting.MONITOR_PORT,
"get_current_memory_info", argv)
data = json.loads(data)
templateString = open(
setting.MAIN_PATH +
'webapi/template/host_getCurrentMemoryInfo.xml').read()
result = ''
for row in table:
hostDict = {'hostID': str(row[0]), 'IP': str(row[1])}
#set default value in case of no data
hostDict['memTotal'] = "-"
hostDict['memTotalUnit'] = "-"
hostDict['memFree'] = "-"
hostDict['memFreeUnit'] = "-"
for element in data:
if element['IP'] == hostDict['IP']:
hostDict['memTotal'] = element['memory_info'][
'MemTotal'][0]
hostDict['memTotalUnit'] = element['memory_info'][
'MemTotal'][1]
hostDict['memFree'] = element['memory_info'][
'MemFree'][0]
hostDict['memFreeUnit'] = element['memory_info'][
'MemFree'][1]
break
result += templateString % hostDict
db.close()
return shortcut.response('success', result)
def makeSlave(targetHostIP,masterHostIP=None): if masterHostIP==None: masterHostIP=cacheFile.getDatabaseIP() result=connection.socketCall(masterHostIP, setting.LOCAL_PORT, 'create_your_slave_db',[str(targetHostIP)]) if result!='OK': return False return True
def index(self,fileName,OS,description,minimumMemory,maximumMemory):
#number format checking
try:
if int(minimumMemory)<0 or int(maximumMemory)<int(minimumMemory):
return shortcut.response('error', '', 'maximumMemory must larger or equal to minimumMemory')
except:
return shortcut.response('error', '', 'memory must be integer')
infoHost=cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD, setting.DB_NAME )
cursor = db.cursor()
#search for fileName (must ask to the nfs server)
cursor.execute("SELECT `IPAddress` FROM `hosts` WHERE `isStorageHolder`=1")
storageHolderIP=cursor.fetchone()[0]
result=connection.socketCall(str(storageHolderIP),setting.LOCAL_PORT,'get_file_size',[setting.TEMPLATE_PATH+fileName])
try:
fileSize=int(json.loads(result)[0])
if fileSize<=0:
return shortcut.response('error', '', 'file not found')
except:
return shortcut.response('error', '', result)
#check replication of fileName
cursor.execute("SELECT `fileName` FROM `templates` WHERE `fileName`='%s'"%(fileName))
if cursor.fetchone()!=None:
return shortcut.response('error', '', 'fileName was used by other template')
#template use different directory with guest
#cursor.execute("SELECT `volumeFileName` FROM `guests` WHERE `volumeFileName`='%s'"%(fileName))
#if cursor.fetchone()!=None:
# return shortcut.response('error', '', 'fileName was used by a guest')
if not fileName.endswith('.img'):
return shortcut.response('error', '', 'please set fileName in pattern of something.img format')
cursor.execute('''
INSERT INTO `templates` (`fileName`, `OS`, `description`, `minimumMemory`, `maximumMemory`,`size`,`activity`) VALUES
('%(fileName)s', '%(OS)s', '%(description)s', '%(minimumMemory)s', '%(maximumMemory)s', '%(size)s', '%(activity)s');
'''%{
'fileName':fileName,
'OS':MySQLdb.escape_string(OS),
'description':MySQLdb.escape_string(description),
'minimumMemory':minimumMemory,
'maximumMemory':maximumMemory,
'size':fileSize,
'activity':0,
})
templateID=cursor.lastrowid
db.close()
content='<template templateID="%s" />'%(str(templateID))
return shortcut.response('success', content)
def getGlobalControllerHostID():
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute("SELECT `hostID` FROM `hosts` WHERE `isGlobalController`=1")
hostID = cursor.fetchone()[0]
db.close()
return hostID
def getDHCPInfoFromDatabase():
'''
read db and return a dict
{networkID, subnetMask, defaultRoute=None, dns=[], hostBindings}
**data must be ready in database
'''
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute("SELECT `key`,`value` from `cloud_variables`;")
cloudData = cursor.fetchall()
dataDict = {}
for element in cloudData:
key = element[0]
value = element[1]
if key == 'network_id':
dataDict['networkID'] = network.IPAddr(value)
elif key == 'subnet_mask':
dataDict['subnetMask'] = network.IPAddr(value)
elif key == 'default_route':
try:
dataDict['defaultRoute'] = network.IPAddr(value)
except:
dataDict['defaultRoute'] = None
elif key == 'dns_servers':
tempList = value.split(',')
dataDict['dns'] = []
for eachDNS in tempList:
try:
dataDict['dns'].append(network.IPAddr(eachDNS))
except:
continue
dataDict['hostBindings'] = []
cursor.execute('''SELECT `MACAddress`,`IPAddress`,`Name` FROM
(
(SELECT `MACAddress`,`IPAddress`,`hostName` as `Name` FROM `hosts`)
UNION
(SELECT `MACAddress`,`IPAddress`,`guestName` as `Name` FROM `guests`)
) AS X
''')
bindData = cursor.fetchall()
db.close()
for element in bindData:
dataDict['hostBindings'].append(
(network.MACAddr(element[0]), network.IPAddr(element[1]),
element[2]))
return dataDict
def migrate(targetHostIP): ''' this method can be called at any host ''' infoHost=cacheFile.getDatabaseIP() result=connection.socketCall(infoHost,setting.LOCAL_PORT,'migrate_database_to',[str(targetHostIP)]) if result=='OK': return True else: return False
def enqueue(detail):
'''
add new task to queue
detail = a dictionary of {'command', 'each parameter'}
return taskID if success
return None if error
'''
try:
form = static.commandToDetail[detail['command']]
except:
print 'Error: no command found'
return None
opcode = form['opcode']
for parameter in form['param']:
if parameter not in detail.keys():
print 'Error: parameter not found -> ' + parameter
return None
if form['isMission']:
isMission = 1
else:
isMission = 0
try:
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
'''
INSERT INTO `tasks` (`opcode`, `isMission`, `detail`, `createTimestamp`) VALUES
( %(opcode)s, %(isMission)s, '%(detail)s', NOW());
''' % {
'opcode': str(opcode),
'isMission': str(isMission),
'detail': json.dumps(detail)
})
taskID = cursor.lastrowid
db.close()
connection.socketCall('localhost', setting.WORKER_PORT, 'start_work',
['{socket_connection}'])
return taskID
except:
print 'have someting wrong with database'
return None
def guest_restore(argv):
'''
restore guest and update database
'''
guestID = argv[0]
volumeFileName = argv[1]
myHostID = argv[2]
saveFileName = volumeFileName.split('.')
saveFileName[-1] = 'sav'
saveFileName = '.'.join(saveFileName)
conn = libvirt.open(None)
if conn == None:
return 'Failed to open connection to the hypervisor'
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
#I'm restoring
cursor.execute("UPDATE `guests` SET `activity`=4 WHERE `guestID`=%s" %
(guestID))
"""
aThread=LongRestoring()
aThread.setArguments(conn,str(guestID),saveFileName,myHostID)
aThread.start()
#new version (blocked method)
if argv[-1]=='{block}':
aThread.join()
"""
result = conn.restore(setting.TARGET_IMAGE_PATH + saveFileName)
if result == -1:
print "restoring fail"
cursor.execute("UPDATE `guests` SET `activity`=-1 WHERE `guestID`=%s" %
(str(guestID)))
db.close()
return result
#finish and tell database that you finish
cursor.execute(
"UPDATE `guests` SET `activity`=0, `status`=1, `lastHostID`=%s WHERE `guestID`=%s"
% (str(myHostID), str(guestID)))
db.close()
try:
os.remove(setting.TARGET_IMAGE_PATH + saveFileName)
except:
print "cannot remove .sav file completely"
return "OK"
def lock(self):
infoHost = cacheFile.getDatabaseIP()
self.db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = self.db.cursor()
cursor.execute("SELECT GET_LOCK('%s','0');" % (self.key))
result = cursor.fetchone()[0]
if result == 1:
return True
elif result == 0:
return False
else:
return False
def index(self):
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute("DELETE FROM `oldHostLoad` WHERE 1")
cursor.execute("DELETE FROM `oldGuestLoad` WHERE 1")
db.close()
content = ''
return shortcut.response('success', content)
def guest_scale_memory(taskID, detail):
#get parameter
guestID = detail['guestID']
memory = detail['memory']
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
#update vCPU to database
try:
cursor.execute("UPDATE `guests` SET `memory`=%s WHERE `guestID`=%s" %
(int(memory), guestID))
except:
db.close()
return 'guestID not found or memory parameter is invalid'
#find hostIPAddress, UUID
cursor.execute('''SELECT `hosts`.`IPAddress` , `lastUUID`
FROM `hosts` INNER JOIN `guests`
ON `hosts`.`hostID`=`guests`.`lastHostID`
AND `guests`.`status`=1 AND `guests`.`activity`=0
AND `guests`.`guestID`=%s;''' % (guestID))
targetData = cursor.fetchone()
db.close()
if targetData == None:
#this is the case when status of that host is 0(shutoff) or 2(saved)
shortcut.storeFinishMessage(
taskID, "This vCPU will not scale until you reboot your guest.")
return 'OK'
hostIP = targetData[0]
UUID = targetData[1]
result = connection.socketCall(hostIP, setting.LOCAL_PORT,
'guest_scale_memory', [UUID, memory])
if result != 'OK':
shortcut.storeFinishMessage(
taskID, "This memory will not scale until you reboot your guest.")
return 'OK' #i intend to do this (not a bug)
content = ""
if not shortcut.storeFinishMessage(taskID, content):
return "cannot storeFinishMessage"
return "OK"
