def loadAll():
manager = Basic.getGridManager()
# The data center "root" node
dcNode = TreeNode("Data Center", constants.DATA_CENTER, "Data Center",
TreeNode.get_state_pixbuf(constants.DATA_CENTER),
"true")
# The list of managed nodes appear 1st
nodes = manager.getNodeList()
for node in nodes:
managed_node = manager.getNode(node)
TreeNode.load_managed_node(managed_node, dcNode)
# now the list of server groups
groups = manager.getGroupList()
groupNames = manager.getGroupNames()
for name in groupNames:
group = groups[name]
TreeNode.load_server_group(group, dcNode)
# the image store
image_store = Basic.getImageStore()
isNode = TreeNode("Image Store", constants.IMAGE_STORE, "Image Store",
TreeNode.get_state_pixbuf(constants.IMAGE_STORE),
"true")
image_groups = image_store.get_image_groups()
# now the list of images
for group in image_groups.itervalues():
TreeNode.load_image_group(group, isNode)
return [dcNode, isNode]
def toXml(self, xml):
data_center_xml = xml.createElement("DataCenter")
servers_xml = xml.createElement("Servers")
manager = Basic.getGridManager()
nodes = manager.getNodeList()
for node in nodes:
managed_node = manager.getNode(node)
self.load_managed_node(managed_node, servers_xml, xml)
if servers_xml.hasChildNodes():
data_center_xml.appendChild(servers_xml)
groups_xml = xml.createElement("ServerGroups")
groups = manager.getGroupList()
group_names = manager.getGroupNames()
for name in group_names:
group = groups[name]
self.load_group(group, groups_xml, xml)
if groups_xml.hasChildNodes():
data_center_xml.appendChild(groups_xml)
return data_center_xml
def get_target_image_groups(self, auth, nodeId):
try:
manager = Basic.getGridManager()
managed_node = manager.getNode(auth, nodeId)
result = []
if managed_node is None:
raise Exception('Cannot find the Managed Node.')
result = []
mnode_ent = auth.get_entity(managed_node.id)
dc_ent = mnode_ent.parents[0].parents[0]
image_groups = self.image_store.get_image_groups(auth,dc_ent.entity_id)
for image_group in image_groups.itervalues():
count = 0
images = self.get_group_images(auth, image_group.id)
for image in images.itervalues():
if managed_node.is_image_compatible(image):
count = count + 1
break
if count > 0:
result.append(dict(name=image_group.get_name(), id=image_group.get_id()))
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return dict(success='true', image_groups=result)
def loadAll():
manager = Basic.getGridManager()
# The data center "root" node
dcNode = TreeNode("Data Center", constants.DATA_CENTER, "Data Center",
TreeNode.get_state_pixbuf(constants.DATA_CENTER), "true")
# The list of managed nodes appear 1st
nodes = manager.getNodeList()
for node in nodes:
managed_node = manager.getNode(node)
TreeNode.load_managed_node(managed_node, dcNode)
# now the list of server groups
groups = manager.getGroupList()
groupNames = manager.getGroupNames()
for name in groupNames:
group = groups[name]
TreeNode.load_server_group(group, dcNode)
# the image store
image_store = Basic.getImageStore()
isNode = TreeNode("Image Store", constants.IMAGE_STORE, "Image Store",
TreeNode.get_state_pixbuf(constants.IMAGE_STORE), "true")
image_groups = image_store.get_image_groups()
# now the list of images
for group in image_groups.itervalues():
TreeNode.load_image_group(group, isNode)
return [dcNode, isNode]
def get_appliance_info(self, auth, domId, nodeId, action):
provider_id = None
manager = Basic.getGridManager()
node = manager.getNode(auth, nodeId)
vm = node.get_dom(domId)
if vm and vm.is_resident() and vm.get_config():
config = vm.get_config()
provider_id = config['provider_id']
result = {}
if provider_id:
proxy = self.get_appliance_ops(provider_id)
app_url, mgmt_url, creds = proxy.get_info(vm)
app_protocol, host, app_port, app_path = app_url
app_mgmt_protocol, host, app_mgmt_port = mgmt_url
username, password = creds
result = dict(app_protocol=app_protocol, host=host, app_port=app_port, app_path=app_path, app_mgmt_protocol=app_mgmt_protocol, app_mgmt_port=app_mgmt_port, username=username, password=password)
result['is_valid'] = proxy.is_valid_info(vm)
web_url = ''
try:
web_url = proxy.get_web_url(vm)
except Exception as e:
print e
result['web_url'] = web_url
if action:
mgmt_web_url = ''
try:
mgmt_web_url = proxy.get_mgmt_web_url(vm, proxy.get_path(action))
except Exception as e:
result['mgmt_web_url'] = mgmt_web_url
return result
def __init__(self):
self.appliance_store = Basic.getApplianceStore()
self.image_store = Basic.getImageStore()
self.manager = Basic.getGridManager()
self.registry = Basic.getPlatformRegistry()
self.node_service = NodeService()
self.storage_manager = Basic.getStorageManager()
def get_target_images(self, auth, nodeId, imageGroupId):
try:
manager = Basic.getGridManager()
managed_node = manager.getNode(auth, nodeId)
if managed_node is None:
raise Exception('Cannot find the Managed Node.')
result = []
image_groups = {}
if imageGroupId is not None:
image_group = self.image_store.get_image_group(auth, imageGroupId)
image_groups = {image_group.get_id():image_group}
else:
image_groups = self.image_store.get_image_groups(auth)
for image_group in image_groups.itervalues():
images = self.image_store.get_group_images(auth, image_group.id)
for image in images.itervalues():
if managed_node.is_image_compatible(image) and not image.is_template:
result.append(dict(name=image.get_name(), id=image.get_id(), group_id=image_group.get_id()))
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return dict(success='true', images=result)
def toXml(self, xml):
data_center_xml = xml.createElement('DataCenter')
servers_xml = xml.createElement('Servers')
manager = Basic.getGridManager()
nodes = manager.getNodeList()
for node in nodes:
managed_node = manager.getNode(node)
self.load_managed_node(managed_node, servers_xml, xml)
if servers_xml.hasChildNodes():
data_center_xml.appendChild(servers_xml)
groups_xml = xml.createElement('ServerGroups')
groups = manager.getGroupList()
group_names = manager.getGroupNames()
for name in group_names:
group = groups[name]
self.load_group(group, groups_xml, xml)
if groups_xml.hasChildNodes():
data_center_xml.appendChild(groups_xml)
return data_center_xml
def __init__(self):
self.appliance_store = Basic.getApplianceStore()
self.image_store = Basic.getImageStore()
self.manager = Basic.getGridManager()
self.registry = Basic.getPlatformRegistry()
self.node_service = NodeService()
self.storage_manager = Basic.getStorageManager()
def get_appliance_menu_items(self, auth, domId, nodeId):
provider_id = None
manager = Basic.getGridManager()
node = manager.getNode(auth, nodeId)
vm = None
try:
vm = node.get_dom(domId)
except Exception, e:
LOGGER.error(to_str(e))
def get_appliance_menu_items(self,auth,domId,nodeId):
provider_id=None
manager = Basic.getGridManager()
node=manager.getNode(auth,nodeId)
vm = None
try:
vm = node.get_dom(domId)
except Exception, e:
LOGGER.error(to_str(e))
def fromStore(node_id, dom_id):
vm_info = VMInfo()
manager = Basic.getGridManager()
managed_node = manager.getNode(node_id)
dom = managed_node.get_dom(dom_id)
vm_info.vm_config = dom.get_config()
vm_info.node_id = node_id
vm_info.dom_id = dom_id
return vm_info
def save_appliance_info(self, auth, domId, nodeId, action, props):
manager = Basic.getGridManager()
node = manager.getNode(auth, nodeId)
vm = node.get_dom(domId)
if vm and vm.get_config():
config = vm.get_config()
provider_id = config['provider_id']
proxy = self.get_appliance_ops(provider_id)
for key in proxy.get_keys():
config[key] = props[key]
manager.save_appliance_info(auth, vm, config)
return self.get_appliance_info(auth, domId, nodeId, action)
def save_appliance_info(self, auth, domId, nodeId, action, props):
manager = Basic.getGridManager()
node = manager.getNode(auth, nodeId)
vm = node.get_dom(domId)
if vm and vm.get_config():
config = vm.get_config()
provider_id = config["provider_id"]
(proxy, ops) = self.get_appliance_ops(provider_id)
for key in proxy.get_keys():
config[key] = props[key]
manager.save_appliance_info(auth, vm, config)
return self.get_appliance_info(auth, domId, nodeId, action)
def get_appliance_menu_items(self, auth, domId, nodeId=None):
provider_id = None
manager = Basic.getGridManager()
vm = manager.get_dom(auth, domId)
if vm and vm.is_running() and vm.get_config():
config = vm.get_config()
provider_id = config['provider_id']
result = []
if provider_id:
proxy,ops = self.get_appliance_ops(provider_id)
for key,desc in ops:
result.append(dict(name=desc, value=key))
return result
def fromXml(xml):
vm_info = VMInfo()
manager = Basic.getGridManager()
registry = Basic.getPlatformRegistry()
image_store = Basic.getImageStore()
node_id = xml.getAttribute("nodeId")
dom_id = xml.getAttribute("domId")
image_id = xml.getAttribute("imageId")
vm_info.node_id = node_id
vm_info.dom_id = dom_id
vm_info.image_id = image_id
managed_node = manager.getNode(node_id)
dom = managed_node.get_dom(dom_id)
platform = managed_node.get_platform()
if dom is None:
platform_object = registry.get_platform_object(platform)
vm_info.vm_config = platform_object.create_vm_config(managed_node)
vm_info.vm_config.platform = platform
vm_info.vm_config.set_managed_node(managed_node)
else:
vm_info.vm_config = dom.get_config()
vm_info.vm_config.platform = platform
vm_info.vm_config.set_managed_node(managed_node)
vm_info.vm_config.image_id = image_id
vm_info.parseVMInfo(xml)
image = image_store.get_image(image_id)
if image is not None:
image_vm_config, image_config = image.get_configs()
vm_info.image_config = image_config
# vm_info.instantiate_configs(managed_node,
# image_store,
# vm_info.vm_config.image_name,
# vm_info.vm_config.image_location,
# vm_info.vm_config,
# vm_info.image_config)
cherrypy.log(vm_info.vm_config.filename)
return vm_info
def get_appliance_info(self, auth, domId, nodeId, action):
provider_id = None
manager = Basic.getGridManager()
node = manager.getNode(auth, nodeId)
vm = node.get_dom(domId)
if vm and vm.is_resident() and vm.get_config():
config = vm.get_config()
provider_id = config["provider_id"]
#print provider_id
result = {}
if provider_id:
(proxy, ops) = self.get_appliance_ops(provider_id)
(app_url, mgmt_url, creds) = proxy.get_info(vm)
(app_protocol, host, app_port, app_path) = app_url
(app_mgmt_protocol, host, app_mgmt_port) = mgmt_url
(username, password) = creds
result = dict(app_protocol=app_protocol,
host=host,
app_port=app_port,
app_path=app_path,
app_mgmt_protocol=app_mgmt_protocol,
app_mgmt_port=app_mgmt_port,
username=username,
password=password)
result['is_valid'] = proxy.is_valid_info(vm)
web_url = ""
try:
web_url = proxy.get_web_url(vm)
except Exception, e:
pass
result['web_url'] = web_url
if action:
mgmt_web_url = ""
try:
mgmt_web_url = proxy.get_mgmt_web_url(
vm, proxy.get_path(action))
except Exception, e:
pass
result['mgmt_web_url'] = mgmt_web_url
def get_target_image_groups(self,auth,nodeId):
try:
manager = Basic.getGridManager()
managed_node = manager.getNode(auth,nodeId)
result=[]
if managed_node is None:
raise Exception('Cannot find the Managed Node.')
result=[]
image_groups = self.image_store.get_image_groups(auth)
for image_group in image_groups.itervalues():
count = 0
images = self.get_group_images(auth,image_group.id)
for image in images.itervalues():
if managed_node.is_image_compatible(image):
count=count+1
break
if count > 0:
result.append(dict(name=image_group.get_name(),id=image_group.get_id()))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
def config_settings(self, auth, image_id, config, mode,\
node_id, group_id, dom_id, vm_name,dateval=None,timeval=None):
task_service = self.svc_central.get_service(self.task_service_id)
user_name = self._get_username(auth)
t= VMConfigSettingsTask(u'Provision VM', {}, [],\
dict(image_id=image_id, config=config, mode=mode,\
node_id=node_id, group_id=group_id, dom_id=dom_id,\
vm_name=vm_name), None, user_name)
if mode == 'PROVISION_VM':
t.set_entity_details(node_id)
elif mode == 'EDIT_VM_INFO':
manager = Basic.getGridManager()
managed_node = manager.getNode(auth, node_id)
if managed_node is not None:
dom = managed_node.get_dom(dom_id)
t.set_entity_details(dom.id)
execution_time = getDateTime(dateval, timeval)
if execution_time is None:
task_service.submit_sync(t)
else:
task_service.submit_schedule(t, execution_time)
logger.debug("Configuration Task Submitted")
def config_settings(self, auth, image_id, config, mode,\
node_id, group_id, dom_id, vm_name,dateval=None,timeval=None):
task_service = self.svc_central.get_service(self.task_service_id)
user_name = self._get_username(auth)
t= VMConfigSettingsTask(u'Provision VM', {}, [],\
dict(image_id=image_id, config=config, mode=mode,\
node_id=node_id, group_id=group_id, dom_id=dom_id,\
vm_name=vm_name), None, user_name)
if mode == 'PROVISION_VM':
t.set_entity_details(node_id)
elif mode == 'EDIT_VM_INFO':
manager=Basic.getGridManager()
managed_node =manager.getNode(auth,node_id)
if managed_node is not None:
dom=managed_node.get_dom(dom_id)
t.set_entity_details(dom.id)
execution_time=getDateTime(dateval,timeval)
if execution_time is None:
task_service.submit_sync(t)
else:
task_service.submit_schedule(t, execution_time)
logger.debug("Configuration Task Submitted")
def __init__(self):
self.service = MetricsService()
self.manager = Basic.getGridManager()
self.utcoffset = None
def __init__(self):
self.service = MetricsService()
self.manager = Basic.getGridManager()
self.utcoffset = None
def __init__(self):
self.storage_manager = Basic.getStorageManager()
self.manager = Basic.getGridManager()
self.sync_manager = SyncDef()
def __init__(self):
self.manager = Basic.getGridManager()
objDic_new[key] = objDic[key]
if objDic_new:
returnVal = objDic_new
else:
returnVal = None
return returnVal
def get_network_models(self):
infolist=[]
infolist.append(dict(name="i82551",value="i82551"))
infolist.append(dict(name="i8255715",value="i8255715"))
infolist.append(dict(name="i82559er",value="i82559er"))
infolist.append(dict(name="ne2k-pci",value="ne2k-pci"))
infolist.append(dict(name="ne2k-isa",value="ne2k-isa"))
infolist.append(dict(name="pcnet",value="pcnet"))
infolist.append(dict(name="rtl8139",value="rtl8139"))
infolist.append(dict(name="rmc91c111",value="rmc91c111"))
infolist.append(dict(name="lance",value="lance"))
infolist.append(dict(name="mef-fec",value="mef-fec"))
infolist.append(dict(name="virtio",value="virtio"))
return infolist
if __name__ == "__main__":
manager = Basic.getGridManager()
managed_node = manager.getNode("Servers", "localhost")
nw=NetworkService()
nw.get_available_nws(managed_node, "PROVISION_VM")
def __init__(self):
self.nw_manager = Basic.getNetworkManager()
self.managed_node = Basic.getManagedNode()
self.sync_manager = SyncDef()
self.manager=Basic.getGridManager()
def __init__(self):
self.storage_manager = Basic.getStorageManager()
self.manager = Basic.getGridManager()
self.sync_manager = SyncDef()
def __init__(self):
self.manager = Basic.getGridManager()
