def purgeDomain(self, req):
conn = util.getConnection()
domain = self.getDomain(req, conn)
ret = dict()
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_OK
if domain == None:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_NOT_FOUND
else:
doc = libxml2.parseDoc(domain.XMLDesc(0))
xml_disks = doc.xpathEval('//disk')
if domain.state(0)[0] == libvirt.VIR_DOMAIN_RUNNING:
domain.destroy()
domain.undefine()
for xml_disk in xml_disks:
if not xml_disk.hasProp('device'):
continue
if xml_disk.prop('device') == 'cdrom':
continue
sub_ele = xml_disk.firstElementChild()
path = None
while sub_ele:
if sub_ele.name == 'source':
path = sub_ele.prop('file') if xml_disk.prop(
'type') == 'file' else sub_ele.prop('dev')
break
sub_ele = sub_ele.nextElementSibling()
if path != None:
try:
vol = conn.storageVolLookupByPath(path)
vol.delete(0)
except:
pass
req.write(json.dumps(ret))
req.finish()
def loadData():
con = util.getConnection()
cf = ColumnFamily(con, 'videos_denorm')
tagCF = ColumnFamily(con, 'tag_videos_composite')
movies = util.readCSV('data/movies')
for movie in movies:
title = movie[0]
uploader = movie[1]
runtime = int(movie[2]) #convert to match column validator
tags = movie[3]
rowKey = title+":"+uploader
print "Inserting in videos: {}.".format(str(movie))
row = \
{
'title':title,
'user_name':uploader,
'runtime_in_sec':runtime,
}
for tag in tags.split(','):
print 'adding tag: {0} for movie: {1}'.format(tag, title)
row['tag:{}'.format(tag.strip().lower())] = tag.strip()
print 'inserting denorm: {}'.format(row)
cf.insert(rowKey, row)
print 'finishished insertion.'
con.dispose()
def listDomains(self, req):
conn = util.getConnection('R')
try:
domainNames = conn.listDefinedDomains()
domains = list()
for name in domainNames:
domain = conn.lookupByName(name)
domains.append(domain)
domainIDs = conn.listDomainsID()
for id in domainIDs:
domain = conn.lookupByID(id)
domains.append(domain)
domainList = list()
for domain in domains:
d = dict()
d["id"] = domain.ID()
d["name"] = domain.name()
d["uuid"] = domain.UUIDString()
d["state"] = domain.state(0)
domainList.append(d)
finally:
conn.close()
req.write(json.dumps(domainList))
req.finish()
def loadData():
con = util.getConnection()
cf = ColumnFamily(con, 'videos')
tagCF = ColumnFamily(con, 'tag_videos_sup')
movies = util.readCSV('data/movies')
for movie in movies:
title = movie[0]
uploader = movie[1]
runtime = int(movie[2]) #convert to match column validator
tags = movie[3]
rowKey = title+":"+uploader
print "Inserting in videos: {}.".format(str(movie))
cf.insert(
rowKey,
{
'title':title,
'user_name':uploader,
'runtime_in_sec':runtime,
'tags_csv': tags
})
for tag in tags.split(','):
print 'adding tag: {0} for movie: {1}'.format(tag, title)
tagCF.insert(
tag.strip().lower(), # row-key = tag name
{
uploader: { # level 1 nesting = uploader name
rowKey: title # level 2 nesting = videoId, value = title
}
}
);
print 'finishished insertion.'
con.dispose()
def get():
#################### TEMP
#userId = 'user-784b9158-5233-454e-8dcf-c229cdff12c6'
print 'Getting result for userId: {0} between time {1} and {2}'.format(userId, startTime, startTime)
con = util.getConnection()
logCF = ColumnFamily(con, 'event_log_mux')
rowKeys = ['{0}:{1}'.format(userId, i+1) for i in range(4)]
rows = logCF.multiget(rowKeys)
print 'Shows rows multiplexes into different rows each individually sorted in reverse cronological order:'
merge = {}
for row in rows:
print '>> '+str(row)
merge = dict(merge.items() + rows[row].items())
for col in rows[row]:
colstr = rows[row][col]
coljson = json.loads(colstr)
print '\tInsertion Timestamp: {0}'.format(coljson['insert_time'])
final = collections.OrderedDict(sorted(merge.items(), reverse=True))
for k,v in final.iteritems():
coljson = json.loads(v)
print 'insertion timestamp: {0}'.format(coljson['insert_time'])
"""
def loadData():
con = util.getConnection()
cf = ColumnFamily(con, 'videos')
tagCF = ColumnFamily(con, 'tag_videos_composite')
movies = util.readCSV('data/movies')
for movie in movies:
title = movie[0]
uploader = movie[1]
runtime = int(movie[2]) #convert to match column validator
tags = movie[3]
rowKey = title+":"+uploader
print "Inserting in videos: {}.".format(str(movie))
row = \
{
'title':title,
'user_name':uploader,
'runtime_in_sec':runtime,
'tags_csv': tags
}
cf.insert(rowKey, row)
print 'inserting tags: {}'.format(tags)
for tag in tags.split(','):
tagCF.insert(
tag.strip().lower(), #row-key = tag name
{
(uploader, rowKey): title #(uploader,videoId)=title
}
);
print 'finishished insertion.'
con.dispose()
def newVol(self, req):
conn = util.getConnection()
ret = dict()
try:
if not req.args.has_key('source'):
raise BaseException()
pool = conn.storagePoolLookupByName(req.args['source'][0])
doc = libxml2.parseDoc(pool.XMLDesc(0))
root = doc.getRootElement()
pool_type = root.prop('type')
poolInfo = pool.info()
disk_size = int(req.args['size'][0])
if disk_size * 1024 * 1024 * 1024 > poolInfo[3]:
raise BaseException()
disk_prefix = None
if req.args.has_key('prefix'):
disk_prefix = req.args['prefix'][0]
else:
disk_prefix = str(uuid.uuid4())
disk_idx = 1
disk_name = disk_prefix + '-' + str(disk_idx)
while True:
try:
pool.storageVolLookupByName(disk_name)
disk_idx = disk_idx + 1
disk_name = disk_prefix + '-' + str(disk_idx)
continue
except:
break
volDoc = libxml2.parseDoc('<volume/>')
volRoot = volDoc.getRootElement()
node = libxml2.newNode('name')
node.setContent(disk_name)
volRoot.addChild(node)
node = libxml2.newNode('capacity')
node.newProp('unit', 'G')
node.setContent(str(disk_size))
volRoot.addChild(node)
if pool_type == 'dir':
node = libxml2.newNode('allocation')
node.newProp('unit', 'G')
node.setContent('0')
volRoot.addChild(node)
vol = pool.createXML(volRoot.serialize(), 0)
ret['prefix'] = disk_prefix
ret['path'] = vol.path()
ret['size'] = vol.info()[1]
except:
pass
finally:
conn.close()
return ret
def queryDomain(self, req):
conn = util.getConnection()
domain = self.getDomain(req, conn)
domainList = list()
if domain != None:
d = dict()
d["id"] = domain.ID()
d["name"] = domain.name()
d["uuid"] = domain.UUIDString()
d["state"] = domain.state(0)
domainList.append(d)
conn.close()
req.write(json.dumps(domainList))
req.finish()
def getPort(self, uuid):
conn = util.getConnection()
try:
domain = conn.lookupByUUIDString(uuid)
doc = libxml2.parseDoc(domain.XMLDesc(0))
graphics = doc.xpathEval('//graphics')
if len(graphics) == 0:
return None
for graphic in graphics:
if graphic.prop('type') == 'vnc':
return int(graphic.prop('port'))
finally:
conn.close()
return None
def getByTag(tag):
con = util.getConnection()
vidCF = ColumnFamily(con, 'videos')
tagCF = ColumnFamily(con, 'tag_videos')
movies = tagCF.get(tag.strip().lower())
for key, val in movies.iteritems():
vidId = key.split('_')[1]
movieDetail = vidCF.get(vidId)
print '''
{{
user: {0},
movie: {1},
tags: {2}
}}'''.format(movieDetail['user_name'], movieDetail['title'], movieDetail['tags_csv'])
con.dispose()
def newMemory(self, req):
conn = util.getConnection()
domain = self.getDomain(req, conn)
ret = dict()
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_OK
if domain == None:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_NOT_FOUND
elif not req.args.has_key('value'):
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER
elif domain.state(0)[0] == libvirt.VIR_DOMAIN_RUNNING:
domain.setMemory(int(req.args['value'][0]))
ret['value'] = int(req.args['value'][0])
else:
ret['value'] = domain.info()[2]
conn.close()
req.write(json.dumps(ret))
req.finish()
def createDomain(self, req):
obj = json.load(req.content)
xmlDef = self.parseDefinition(obj, req)
if xmlDef != None:
try:
conn = util.getConnection()
dom = conn.defineXML(xmlDef)
# dom.create()
res = dict()
res['code'] = self.__class__.DOMAIN_ERROR_CODE_OK
res['name'] = dom.name()
res['uuid'] = dom.UUIDString()
res['state'] = dom.state(0)
req.write(json.dumps(res))
req.finish()
return
finally:
conn.close()
def randomEvent(i, events):
event = random.choice(events)
con = util.getConnection()
eventsCF = ColumnFamily(con, 'event_log')
for j in range(50):
event = random.choice(events)
rowkey = event['user']
timestamp = datetime.datetime.utcnow()
colval = json.dumps(event)
print '[Thread:{3}] Inserting: [{0}=> {{{1}:{2}}}]'.format(rowkey, timestamp, colval, i)
eventsCF.insert(rowkey, {timestamp: colval})
time.sleep(0.1) #100 milliseconds
print 'finishished insertion.'
con.dispose()
def destroyDomain(self, req):
conn = util.getConnection()
domain = self.getDomain(req, conn)
ret = dict()
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_OK
if domain == None:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_NOT_FOUND
elif domain.state(0)[0] == libvirt.VIR_DOMAIN_RUNNING:
try:
domain.destroy()
except:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_SYS_ERROR
ret['state'] = domain.state(0)[0]
else:
ret['state'] = domain.state(0)[0]
conn.close()
req.write(json.dumps(ret))
req.finish()
def getByTag(tag):
print '''-- MOVIES GROUPED BY USER FOR A GIVE TAG --'''
print '''tag: {}'''.format(tag)
con = util.getConnection()
tagCF = ColumnFamily(con, 'tag_videos_sup')
movies = tagCF.get(tag.strip().lower())
for key, val in movies.iteritems():
username = key
print '''
{{
{0}:'''.format(username)
for k, v in val.iteritems():
print '''\t{{{0}=> {1}}}'''.format(k, v)
print '''
}'''
con.dispose()
def getByTag(tag):
print '''-- MOVIES GROUPED BY USER FOR A GIVE TAG --'''
print '''tag: {}'''.format(tag)
con = util.getConnection()
tagCF = ColumnFamily(con, 'tag_videos_composite')
movies = tagCF.get(tag.strip().lower())
for key, val in movies.iteritems():
compositeCol = key
print '([{0}],[{1}]) => {2}'.format(compositeCol[0], compositeCol[1], val)
movieSlice = tagCF.get(tag.strip().lower(), column_start=("Kara", "The Croods:Kara"), column_finish=("Sally","Gx" ))
#movieSlice = tagCF.get(tag.strip().lower(), column_start=("Kara", ), column_finish=(("Leo Scott",False),))
print '-- SLICES --'
for key, val in movieSlice.iteritems():
compositeCol = key
print '([{0}],[{1}]) => {2}'.format(compositeCol[0], compositeCol[1], val)
con.dispose()
def newNet(self, req):
conn = util.getConnection()
domain = self.getDomain(req, conn)
ret = dict()
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_OK
if domain == None:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_NOT_FOUND
else:
if not req.args.has_key('source'):
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER
else:
doc = libxml2.parseDoc(
"<interface type='network'></interface>")
root = doc.getRootElement()
node = libxml2.newNode('mac')
mac = req.args['mac'][0] if req.args.has_key(
'mac') else self.generateMAC()
node.newProp('address', mac)
root.addChild(node)
try:
source = req.args['source'][0]
conn.networkLookupByName(source)
node = libxml2.newNode('source')
node.newProp('network', source)
root.addChild(node)
flag = libvirt.VIR_DOMAIN_AFFECT_CONFIG
if domain.state(0)[0] == libvirt.VIR_DOMAIN_RUNNING:
flag |= libvirt.VIR_DOMAIN_AFFECT_LIVE
if domain.attachDeviceFlags(root.serialize(), flag) > 0:
#libvirt.VIR_DOMAIN_AFFECT_CURRENT) > 0:
raise BaseException()
ret['source'] = source
ret['mac'] = mac
except:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_SYS_ERROR
conn.close()
req.write(json.dumps(ret))
req.finish()
def randomEvent(i, events):
global THREAD_DONE
event = random.choice(events)
con = util.getConnection()
eventsCF = ColumnFamily(con, 'event_log_mux')
for j in range(10):
event = random.choice(events)
event['insert_time'] = time.time()
user = event['user']
muxid = random.randint(1, MUX)
rowkey = '{0}:{1}'.format(user, muxid)
timestamp = datetime.datetime.utcnow()
colval = json.dumps(event)
print '[Thread:{3}] Inserting: [{0}=> {{{1}:{2}}}]'.format(rowkey, timestamp, colval, i)
eventsCF.insert(rowkey, {timestamp: colval})
time.sleep(0.1) #100 milliseconds
THREAD_DONE[i] = True
print 'finishished insertion.'
con.dispose()
def listVol(self, req):
vols = list()
conn = util.getConnection()
try:
if not req.args.has_key('pool'):
raise BaseException()
pool = conn.storagePoolLookupByName(req.args['pool'][0])
vol_names = pool.listVolumes()
for vol_name in vol_names:
vol = pool.storageVolLookupByName(vol_name)
d = dict()
d['name'] = vol.name()
d['path'] = vol.path()
d['size'] = vol.info()[1]
vols.append(d)
except:
pass
finally:
conn.close()
req.write(json.dumps(vols))
req.finish()
def info(self, req):
conn = util.getConnection()
res = dict()
info = conn.getInfo()
res['arch'] = info[0]
res['cpus'] = info[2]
res['freq'] = info[3]
f = file('/proc/uptime')
with f:
data = f.read()
arr = data.split(' ')
res['uptime'] = int(float(arr[0]))
res['memory'] = conn.getMemoryStats(-1, 0)
ifaces = util.listInterfaces()
res['ifaces'] = list()
for iface in ifaces:
if iface[0] == 'lo':
continue
res['ifaces'].append(iface)
res['net'] = self.listNet(conn)
res['pool'] = self.listPool(conn)
req.write(json.dumps(res))
req.finish()
def getVids(username, max_length=0):
con = util.getConnection()
videoCF = ColumnFamily(con, 'videos')
username_criteria = create_index_expression('user_name', username)
length_criteria = create_index_expression('runtime_in_sec', max_length, LTE) #LTE? Less than or equals
user_only_clause = create_index_clause([username_criteria], count=3) #just pull 3
movies_by_user = videoCF.get_indexed_slices(user_only_clause)
print '''-- movies for username: {} --'''.format(username)
print_movie(movies_by_user)
user_runtime_clause = create_index_clause([username_criteria, length_criteria]) #pull all
movies_by_user_runtime = videoCF.get_indexed_slices(user_runtime_clause)
print '''-- movies for username: {} and length <= {} --'''.format(username, max_length)
print_movie(movies_by_user_runtime)
"""
# Intended to fail
runtime_clause = create_index_clause([length_criteria]) # At least on equality neccessary!
movies_by_runtime = videoCF.get_indexed_slices(runtime_clause)
print '''-- movies for length <= {} --'''.format(max_length)
print_movie(movies_by_runtime)
"""
con.dispose()
def loadData():
con = util.getConnection()
cf = ColumnFamily(con, 'videos')
movies = util.readCSV('data/movies')
for movie in movies:
title = movie[0]
uploader = movie[1]
runtime = int(movie[2]) #convert to match column validator
tags = movie[3]
rowKey = title+":"+uploader
print "Inserting in videos: {}.".format(str(movie))
cf.insert(
rowKey,
{
'title':title,
'user_name':uploader,
'runtime_in_sec':runtime,
'tags_csv': tags
})
print 'finishished insertion.'
con.dispose()
def newPool(self, req):
ret = dict()
ret['code'] = 0
try:
if not req.args.has_key('type'):
ret['code'] = 1001
ret['desc'] = "No type parameter"
raise BaseException()
pool_type = req.args['type'][0]
if not req.args.has_key('name'):
ret['code'] = 1001
ret['desc'] = "No name parameter"
raise BaseException()
name = req.args['name'][0]
doc = libxml2.parseDoc("<pool/>")
root = doc.getRootElement()
if pool_type == 'logical':
root.newProp('type', 'logical')
node = libxml2.newNode('name')
node.setContent(name)
root.addChild(node)
node = libxml2.newNode('target')
if not req.args.has_key('dev'):
ret['code'] = 1003
ret['desc'] = "Parameter dev invalid"
raise BaseException()
dev = req.args['dev'][0]
if not os.path.exists(dev):
ret['code'] = 1003
ret['desc'] = 'Parameter dev invalid'
raise BaseException()
path = libxml2.newNode('path')
path.setContent(dev)
node.addChild(path)
root.addChild(node)
elif pool_type == 'dir':
root.newProp('type', 'dir')
node = libxml2.newNode('name')
node.setContent(name)
root.addChild(node)
node = libxml2.newNode('target')
path = libxml2.newNode('path')
if not req.args.has_key('dev') or len(req.args['dev'][0]) == 0:
ret['code'] = 1003
ret['desc'] = "Parameter path invalid"
raise BaseException()
dev = req.args['dev'][0]
if not os.path.isdir(dev):
ret['code'] = 1003
ret['desc'] = "Path doesn't exists"
raise BaseException()
path.setContent(dev)
node.addChild(path)
root.addChild(node)
elif pool_type == 'netfs' or pool_type == 'iscsi':
root.newProp('type', pool_type)
node = libxml2.newNode('name')
node.setContent(name)
root.addChild(node)
node = libxml2.newNode('source')
if not req.args.has_key('host'):
ret['code'] = 1004
ret['desc'] = 'Parameter host invalid'
raise BaseException()
subNode = libxml2.newNode('host')
subNode.newProp('name', req.args['host'][0])
node.addChild(subNode)
if pool_type == 'netfs':
if not req.args.has_key('src_path'):
ret['code'] = 1004
ret['desc'] = 'Parameter src_path invalid'
raise BaseException()
subNode = libxml2.newNode('dir')
subNode.newProp('path', req.args['src_path'][0])
node.addChild(subNode)
else:
if not req.args.has_key('device'):
ret['code'] = 1004
ret['desc'] = 'Parameter device invalid'
raise BaseException()
subNode = libxml2.newNode('device')
subNode.newProp('path', req.args['device'][0])
node.addChild(subNode)
root.addChild(node)
if not req.args.has_key('target_path') or not os.path.isdir(req.args['target_path'][0]):
ret['code'] = '1004'
ret['desc'] = "Parameter target path invalid"
raise BaseException()
node = libxml2.newNode('target')
subNode = libxml2.newNode('path')
subNode.setContent(req.args['target_path'][0])
node.addChild(subNode)
permission = libxml2.newNode('permissions')
subNode = libxml2.newNode('owner')
subNode.setContent('-1')
permission.addChild(subNode)
subNode = libxml2.newNode('group')
subNode.setContent('-1')
permission.addChild(subNode)
subNode = libxml2.newNode('mode')
subNode.setContent('0700')
permission.addChild(subNode)
node.addChild(permission)
root.addChild(node)
else:
ret['code'] = 1002
ret['desc'] = "Invalid storage type"
raise BaseException()
conn = util.getConnection()
pool = None
try:
pool = conn.storagePoolDefineXML(root.serialize(), 0)
if int(req.args['auto_start'][0]) != 0:
pool.setAutostart(True)
pool.create(0)
except:
ret['code'] = 10000
ret['desc'] = 'Unable to create poool'
if pool != None:
pool.undefine()
conn.close()
raise
ret['name'] = name
ret['type'] = pool_type
doc = libxml2.parseDoc(pool.XMLDesc(0))
nodes = doc.xpathEval('//uuid')
if len(nodes) > 0:
ret['uuid'] = nodes[0].getContent()
nodes = doc.xpathEval('//capacity')
if len(nodes) > 0:
ret['capacity'] = nodes[0].getContent()
nodes = doc.xpathEval('//allocation')
if len(nodes) > 0:
ret['allocation'] = nodes[0].getContent()
nodes = doc.xpathEval('//available')
if len(nodes) > 0:
ret['available'] = nodes[0].getContent()
conn.close()
except:
pass
req.write(json.dumps(ret))
req.finish()
def domainInfo(self, req):
conn = util.getConnection()
domain = self.getDomain(req, conn)
ret = dict()
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_OK
if domain == None:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_NOT_FOUND
else:
info = domain.info()
ret['state'] = info[0]
ret['max_memory'] = info[1]
ret['memory'] = info[2]
ret['vcpus'] = info[3]
if info[0] == libvirt.VIR_DOMAIN_RUNNING:
cpus = dict()
cpus = domain.getCPUStats(1, 0)[0]
cpus['cpus'] = [
i['cpu_time'] for i in domain.getCPUStats(0, 0)
]
ret['cpus'] = cpus
doc = libxml2.parseDoc(domain.XMLDesc(0))
xml_disks = doc.xpathEval('//disk')
disks = list()
for xml_disk in xml_disks:
if not xml_disk.hasProp('device'):
continue
if xml_disk.prop('device') == 'cdrom':
cdrom = dict()
cdrom['type'] = xml_disk.prop('type')
sub_ele = xml_disk.firstElementChild()
while sub_ele:
if sub_ele.name == 'source':
cdrom['path'] = sub_ele.prop(
'file') if xml_disk.prop(
'type') == 'file' else sub_ele.prop('dev')
break
sub_ele = sub_ele.nextElementSibling()
ret['cdrom'] = cdrom
else:
disk = dict()
sub_ele = xml_disk.firstElementChild()
while sub_ele:
if sub_ele.name == 'source':
path = sub_ele.prop('file') if xml_disk.prop(
'type') == 'file' else sub_ele.prop('dev')
try:
vol = conn.storageVolLookupByPath(path)
disk['name'] = vol.name()
disk['size'] = vol.info()[1]
disk['pool'] = vol.storagePoolLookupByVolume(
).name()
except:
pass
elif sub_ele.name == 'target':
disk['target'] = sub_ele.prop('dev')
sub_ele = sub_ele.nextElementSibling()
disks.append(disk)
ret['disks'] = disks
xml_nets = doc.xpathEval("//interface")
nets = list()
for xml_net in xml_nets:
if xml_net.prop("type") != 'network':
continue
net = dict()
sub_ele = xml_net.firstElementChild()
while sub_ele:
if sub_ele.name == 'mac':
net['mac'] = sub_ele.prop('address')
elif sub_ele.name == 'source':
net['source'] = sub_ele.prop('network')
elif sub_ele.name == 'alias':
net['serial'] = sub_ele.prop('name')[-1:]
elif sub_ele.name == 'target':
try:
net_stat = domain.interfaceStats(
sub_ele.prop('dev'))
stat_names = ('rx_bytes', 'rx_packets', 'rx_errs',
'rx_drop', 'tx_bytes', 'tx_packets',
'tx_errs', 'tx_drop')
net['stat'] = dict()
for i in xrange(len(net_stat)):
net['stat'][stat_names[i]] = net_stat[i]
except:
pass
sub_ele = sub_ele.nextElementSibling()
nets.append(net)
ret['net'] = nets
req.write(json.dumps(ret))
req.finish()
conn.close()
def parseDefinition(self, obj, req):
name = obj.get('name')
UUID = obj.get('uuid')
if UUID == None or len(UUID) == 0:
UUID = str(uuid.uuid4())
if name == None or len(name) == 0:
name = UUID
memory = obj.get('memory')
if memory == None:
return self.respond(req,
self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER,
"Memory value invalid")
else:
try:
memory = int(memory)
except:
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER,
"Memory value invalid")
maxMemory = obj.get('maxMemory')
if maxMemory == None:
maxMemory = memory
else:
try:
maxMemory = int(maxMemory)
except:
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER,
"Max memory value invalid")
vcpus = obj.get('vcpu')
if vcpus == None:
vcpus = 1
else:
try:
vcpus = int(vcpus)
except:
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER,
"vcpu value invalid")
disks = obj.get('disks')
if disks != None:
if not isinstance(disks, list):
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER,
"Invalid disk parameter")
cdrom = obj.get('cdrom')
interfaces = obj.get('interfaces')
if interfaces != None:
if not isinstance(interfaces, list):
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER,
"Invalid interface parameter")
try:
conn = util.getConnection()
domain = None
try:
domain = conn.lookupByName(str(name))
except:
pass
if domain != None:
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_NAME_DUPLICATED,
"Domain name dulicated")
nodeInfo = conn.getInfo()
if vcpus > nodeInfo[2]:
vcpus = nodeInfo[2]
if memory > nodeInfo[1] * 1024:
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_INADEQUATE_MEMORY,
"Not enough memory")
doc = libxml2.parseFile('/etc/cloudyfox/template.xml')
root = doc.getRootElement()
node = libxml2.newNode('name')
node.setContent(name)
root.addChild(node)
node = libxml2.newNode("uuid")
node.setContent(UUID)
root.addChild(node)
node = libxml2.newNode('memory')
node.newProp("unit", "KiB")
node.setContent(str(maxMemory))
root.addChild(node)
node = libxml2.newNode("currentMemory")
node.newProp("unit", "KiB")
node.setContent(str(memory))
root.addChild(node)
node = libxml2.newNode("vcpu")
node.newProp("placement", "static")
node.setContent(str(vcpus))
root.addChild(node)
result = doc.xpathEval("//devices")
devices = result[0]
if disks != None:
diskIdx = 1
for disk in disks:
if not os.path.exists(disk):
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_NO_DISK,
"Unable to find disk")
diskNode = libxml2.newNode('disk')
st = os.stat(disk)
diskType = 'block' if stat.S_ISBLK(st.st_mode) else 'file'
diskNode.newProp('type', diskType)
diskNode.newProp('device', 'disk')
node = libxml2.newNode('source')
if diskType == 'block':
node.newProp('dev', disk)
else:
node.newProp('file', disk)
diskNode.addChild(node)
node = libxml2.newNode('target')
node.newProp('bus', 'virtio')
node.newProp('dev', 'vd' + chr(ord('a') + (diskIdx - 1)))
diskNode.addChild(node)
devices.addChild(diskNode)
diskIdx = diskIdx + 1
cdromNode = libxml2.newNode('disk')
cdromNode.newProp('type', 'file')
cdromNode.newProp('device', 'cdrom')
if cdrom != None and os.path.isfile(cdrom):
node = libxml2.newNode('source')
node.newProp('file', cdrom)
cdromNode.addChild(node)
node = libxml2.newNode('target')
node.newProp('dev', 'hdc')
node.newProp('bus', 'ide')
cdromNode.addChild(node)
devices.addChild(cdromNode)
if interfaces != None:
networks = conn.listNetworks()
if len(networks) == 0:
return self.respond(
req, self.__class__.DOMAIN_ERROR_CODE_INTERFACE_ERROR,
"No network defined")
for interface in interfaces:
if not isinstance(interface,
dict) or not interface.has_key('source'):
return self.respond(
req,
self.__class__.DOMAIN_ERROR_CODE_INTERFACE_ERROR,
"No eth defined")
netName = interface['source']
if not netName in networks:
return self.respond(
req,
self.__class__.DOMAIN_ERROR_CODE_INTERFACE_ERROR,
"No such eth")
mac = interface.get('mac')
if mac == None:
mac = self.generateMAC()
netNode = libxml2.newNode('interface')
netNode.newProp('type', 'network')
node = libxml2.newNode('source')
node.newProp('network', netName)
netNode.addChild(node)
node = libxml2.newNode('mac')
node.newProp('address', mac)
netNode.addChild(node)
node = libxml2.newNode('model')
node.newProp('type', 'virtio')
netNode.addChild(node)
devices.addChild(netNode)
xmlData = root.serialize()
doc.freeDoc()
return xmlData
finally:
conn.close()
def attachDisk(self, req):
conn = util.getConnection()
domain = self.getDomain(req, conn)
ret = dict()
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_OK
if domain == None:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_NOT_FOUND
else:
try:
diskDoc = libxml2.parseDoc("<disk/>")
diskRoot = diskDoc.getRootElement()
node = libxml2.newNode('driver')
node.newProp('name', 'qemu')
node.newProp('type', 'raw')
diskRoot.addChild(node)
target_path = None
if req.args.has_key('cdrom'):
if not os.path.exists(req.args['cdrom'][0]):
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_SYS_ERROR
raise BaseException()
diskRoot.newProp('type', 'file')
diskRoot.newProp('device', 'cdrom')
node = libxml2.newNode('source')
node.newProp('file', req.args['cdrom'][0])
diskRoot.addChild(node)
node = libxml2.newNode('target')
node.newProp('dev', 'hdc')
node.newProp('tray', 'closed')
diskRoot.addChild(node)
node = libxml2.newNode('readonly')
diskRoot.addChild(node)
target_path = 'hdc'
elif not req.args.has_key('disk'):
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_SYS_ERROR
raise BaseException()
else:
if domain.info()[0] == libvirt.VIR_DOMAIN_RUNNING:
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_SYS_ERROR
raise BaseException()
domainDoc = libxml2.parseDoc(domain.XMLDesc(0))
xml_disks = domainDoc.xpathEval('//disk')
disk_idx = 1
for xml_disk in xml_disks:
if not xml_disk.hasProp('device'):
continue
if xml_disk.prop('device') == 'cdrom':
continue
disk_idx = disk_idx + 1
target_path = 'vd' + chr(ord('a') + (disk_idx - 1))
disk_name = req.args['disk'][0]
if not os.path.exists(disk_name):
ret['code'] = self.__class__.DOMAIN_ERROR_CODE_BAD_PARAMETER
raise BaseException()
vol = conn.storageVolLookupByPath(disk_name)
ret['size'] = vol.info()[1]
st = os.stat(disk_name)
if stat.S_ISBLK(st.st_mode):
diskRoot.newProp('type', 'block')
else:
diskRoot.newProp('type', 'file')
diskRoot.newProp('device', 'disk')
node = libxml2.newNode('source')
if stat.S_ISBLK(st.st_mode):
node.newProp('dev', disk_name)
else:
node.newProp('file', disk_name)
diskRoot.addChild(node)
node = libxml2.newNode('target')
node.newProp('dev', target_path)
node.newProp('bus', 'virtio')
diskRoot.addChild(node)
if domain.attachDeviceFlags(
diskRoot.serialize(),
libvirt.VIR_DOMAIN_AFFECT_CURRENT) > 0:
raise BaseException()
ret['target'] = target_path
except:
pass
conn.close()
req.write(json.dumps(ret))
req.finish()
