def get_nws(self,auth,image_id=None,dom_id=None,node_id=None, op_level=None): vm_config=None if dom_id is not None: # dom=NodeService().get_dom(auth,dom_id,node_id) dom=DBHelper().find_by_name(VM,dom_id) vm_config=dom.get_config() elif image_id is not None: image=ImageService().get_image(auth,image_id) (vm_config,img_conf)=image.get_configs() if not vm_config: return managed_node=None if node_id is not None: managed_node=NodeService().get_managed_node(auth,node_id) if managed_node is not None: self.managed_node=managed_node vifs = vm_config.getNetworks() result=[] for vif in vifs: result.append(self.get_nw_entry(vif, op_level)) 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_new_nw(self,auth,image_id,mode,node_id, op_level=None): # if image_id is not None: # image=ImageService().get_image(auth,image_id) # (vm_config,image_config)=image.get_configs() result=[] if mode in ["edit_image_settings","provision_vm","provision_image"]: (vif_entry, nw_entry) = self.get_new_nw_entry() else: managed_node=NodeService().get_managed_node(auth,node_id) # generate mac address and get the DEFAULT_BRIDGE if any mac=randomMAC() if managed_node is not None: bridge = managed_node.get_default_bridge() if not bridge: bridge="xenbr0" if managed_node.platform == 'kvm': bridge='br0' vif_entry=vifEntry('mac=%s,bridge=%s' % (mac,bridge)) nw_entry = None # for vif in vif_entry: result.append(self.get_nw_entry(vif_entry, op_level)) return result
def get_image_groups(self,auth,store_id=None): image_groups = self.get_groups(auth,store_id) result = [] for image_group in image_groups: childnode=NodeService().get_childnodestatus(auth,image_group.id) result.append({'NODE_NAME':image_group.name,'NODE_ID':image_group.id, 'NODE_TYPE':constants.IMAGE_GROUP,'NODE_CHILDREN':childnode}) return result
def exec_task(self, auth, ctx, node_id, directory,filenames): manager = Basic.getGridManager() managed_node = manager.getNode(auth, node_id) if managed_node is not None: if not managed_node.is_authenticated(): managed_node.connect() NodeService().import_vm_config(auth,node_id, directory,filenames) # return manager.do_node_action(auth, node_id, action) else: raise Exception("Can not find the managed node")
def get_available_nws(self, auth,mode,node_id, op_level=None): result=[] if mode in ["edit_image_settings"]: result = available_nws else: # "PROVISION_VM", "EDIT_VM_CONFIG" nw_map = {} managed_node=NodeService().get_managed_node(auth,node_id) if mode in ["provision_vm" ,"provision_image"]: nw_map["Default"] = "$DEFAULT_BRIDGE" result.append(dict(value="$DEFAULT_BRIDGE",name="Default")) bridges = managed_node.get_bridge_info() site_id=None group_id = None #set the op_level none so that we can get all the networks created on the server (networks present in serverdeflinks table for that server) op_level=None for nw in self.nw_manager.get_defns(to_unicode(constants.NETWORK), site_id, group_id, node_id, op_level): bridge=None network = None if nw.ipv4_info and nw.ipv4_info.get("ip_network"): network = nw.ipv4_info.get("ip_network") if nw.bridge_info and nw.bridge_info.get("name"): bridge = nw.bridge_info.get("name") if bridge and network: desc = "%s (%s, %s)" % (nw.name, bridge, network) elif bridge: desc = "%s (%s)" % (nw.name, bridge,) elif network: desc = "%s (%s)" % (nw.name, network,) if nw.bridge_info and nw.bridge_info.get("name"): nw_map[desc] = nw.bridge_info.get("name") result.append(dict(value=nw.bridge_info.get("name"),name=desc)) if bridges is not None: for n in bridges.itervalues(): name = n["name"] if name not in nw_map.itervalues(): desc = name + " network" if n.get("network"): desc = "%s (%s,%s)" % (desc, name, n["network"]) nw_map[desc] = name result.append(dict(value=name,name=desc)) #init_combo(self.widgets.available_nw_combo,nw_map) return result
def get_images(self, auth,group_id, platform = None): images = self.get_group_images(auth,group_id) result=[] # Sort the images if images: image_list = [ x for x in images.itervalues() if (platform is None or x.platform == platform)] image_list.sort(key=lambda(x) : x.get_name()) else: image_list = [] for image in image_list: childnode=NodeService().get_childnodestatus(auth,image.id) result.append({'NODE_NAME':image.name,'NODE_ID':image.id, 'NODE_TYPE':constants.IMAGE,'NODE_CHILDREN':childnode}) return result
def get_vif_entry(self,auth,mode,node_id): if mode in ["EDIT_IMAGE","PROVISION_VM"]: (vif_entry, nw_entry) = self.get_new_nw_entry(None) else: # generate mac address and get the DEFAULT_BRIDGE if any managed_node=NodeService().get_managed_node(auth,node_id) mac=randomMAC() if managed_node is not None: bridge = managed_node.get_default_bridge() if not bridge: bridge="xenbr0" if managed_node.platform == 'kvm': bridge='br0' vif_entry=vifEntry('mac=%s,bridge=%s' % (mac,bridge)) return vif_entry
class TemplateController(ControllerBase): """ """ image_service=ImageService() node_service = NodeService() vm_service=VMService() # @expose(template='json') def get_image_groups(self,store_id=None,_dc=None): try: self.authenticate() result = self.image_service.get_image_groups(session['auth'],store_id) result = json.dumps(dict(success=True,nodes=result)) return result except Exception, ex: print_traceback() return dict(success=False,msg=to_str(ex).replace("'", " "))
class ControllerImpl(ControllerBase): node_service=NodeService() user_info=Userinfo() tc = TaskCreator() email_service=EmailService() def login(self, came_from=url('/')): """Start the user login.""" if session.get('userid') is None and request.identity is not None: self.redirect_to(url('/user_logout')) # login_counter = request.environ['repoze.who.logins'] # if login_counter > 0: # flash(_('Wrong credentials'), 'warning') return dict(page='login',came_from=came_from) def user_login(self,args): try: username = args.get('login') password = args.get('password') user = DBSession.query(User).filter(User.user_name==username).first() if user: if user.status != True: msg="User: "******" is not Active." LOGGER.info(msg) return dict(success=False,user=None,msg=msg) sqa_sts = user.validate_password(password) if not sqa_sts: msg="Invalid password provided for CMS authentication." LOGGER.info(msg) return dict(success=False,user=None,msg=msg) if not len(user.groups): msg="User should belongs to a group" LOGGER.info(msg) return dict(success=False,user=None,msg=msg) else: msg="Invalid username provided for CMS authentication." LOGGER.info(msg) return dict(success=False,user=None,msg=msg) return dict(success=True,user=username) except Exception, e: print "Exception", e LOGGER.error(e) return dict(success=False,user=None,msg=str(e))
def get_nw_nat_fwding_map(self,auth,node_id ): result=[] try: nw_nat_fwding_map = {"Any interface" : "ANY",} managed_node=NodeService().get_managed_node(auth,node_id) if managed_node is not None: nics = managed_node.get_nic_info() if nics: for nic in nics.itervalues(): nic_name = nic["name"] nw_nat_fwding_map[nic_name] = nic_name for key in nw_nat_fwding_map.keys(): result.append(dict(name=key,value=nw_nat_fwding_map.get(key))) except Exception, ex: print_traceback() LOGGER.error(to_str(ex).replace("'","")) raise ex
class NodeController(ControllerBase): """ """ #allow_only = authenticate() #/node/ tc = TaskCreator() node_service = NodeService() vm_service = VMService() # @expose(template='json') def get_platform(self, node_id, type, **kw): try: self.authenticate() result = self.node_service.get_platform(session['auth'], node_id, type) except Exception, ex: print_traceback() return {'success': 'false', 'msg': to_str(ex).replace("'", "")} return dict(success='true', platform=result)
def get_all_known_bridges(self,auth,node_id,group_id,site_id, op_level=None): bridge_names = [] managed_node=NodeService().get_managed_node(auth,node_id) if managed_node is not None: bridges = managed_node.get_bridge_info() if bridges: bridge_names = bridge_names + bridges.keys() if self.nw_manager: # pool_id, node_id = get_ids_from_context(self.context) #we are passing group_id here for getting server pool level definitions defns = self.nw_manager.get_defns(to_unicode(constants.NETWORK), site_id, group_id, node_id, op_level) #check None here if defns is not None: for defn in defns: if defn.bridge_info and defn.bridge_info["name"]: n = defn.bridge_info["name"] if n not in bridge_names: bridge_names.append(n) return bridge_names
def remove_nw_defn(self,auth,def_id, site_id, group_id, node_id, op_level=None): try: def_id=(def_id) node_id=(node_id) nw_def = self.nw_manager.get_defn(def_id) # print "reeeeeeeeee",nw_def # network_name=nw_def.name # manager = Basic.getGridManager() # group=manager.getGroup(pool_id) site=self.manager.getSite(site_id) group=None if group_id: group= DBSession.query(ServerGroup).filter_by(id = group_id).first() managed_node=NodeService().get_managed_node(auth,node_id) group_list = self.manager.getGroupList(auth, site_id) add_mode=False self.sync_manager.remove_defn(nw_def, site, group, managed_node, auth, to_unicode(constants.NETWORK), constants.DETACH, "REMOVE_NETWORK_DEF", self.nw_manager, self.manager, add_mode, group_list, op_level) except Exception, ex: print_traceback() LOGGER.error(to_str(ex).replace("'","")) return {'success':False,'msg':to_str(ex).replace("'","")}
def exec_task(self, auth, ctx, node_id,text,user): LOGGER.debug('Entered in excec_task for EditAnnotationTask') msg=NodeService().process_annotation(auth,node_id,text,user) return dict(results=msg, visible=True, status=Task.SUCCEEDED)
def exec_task(self, auth, ctx, node_id): LOGGER.debug('Entered in excec_task for ClearAnnotationTask') msg=NodeService().clear_annotation(auth,node_id) return dict(results=msg, visible=True, status=Task.SUCCEEDED)
def add_nw_defn(self,auth,nw_name,nw_desc,nw_device,nw_address_space,nw_dhcp_range,nat_radio,nw_nat_fwding,site_id,group_id,node_id,scope=None): # print "nw_desc,nw_device,nw_address_space,nw_dhcp_range,nw_nat_fwding,pool_id,node_id", nw_name=(nw_name) nw_desc=(nw_desc) nw_device=(nw_device) nw_address_space=(nw_address_space) nw_dhcp_range=(nw_dhcp_range) node_id=(node_id) ## Jd ## For now create host private networks. ## This needs to be revisited when we add VLAN support. scope=constants.SCOPE_S if site_id == 'data_center': site = self.manager.getSiteByGroupId(group_id) if site: site_id = site.id else: site = self.manager.getSite(site_id) group_list = self.manager.getGroupList(auth, site_id) try: nw_id = None group = None managed_node = None new_nw_def = None #we were getting server pool None so we have added this query here if group_id: group= DBSession.query(ServerGroup).filter_by(id = group_id).first() managed_node=NodeService().get_managed_node(auth,node_id) # if is_public=='true': # nw_type = NwDef.PUBLIC_NW # else: # nw_type = NwDef.HOST_PRIVATE_NW #nw_type= self.get_nw_type() nw_type=NwDef.HOST_PRIVATE_NW #Set to Private Network for now errors=self.validate_new_nw_def(auth,"ADD",nw_type,nw_name,nw_desc,nw_device,nw_address_space,nw_dhcp_range,nat_radio,nw_nat_fwding,site_id,group_id,node_id, scope) if errors: if len(errors)>0: return {'success':False,'msg':to_str(errors).replace("'","")} if nw_type == NwDef.PUBLIC_NW: # nw_device = nw_device_entry nw_phy_if = nw_phy_if_entry bridge_info = dynamic_map() bridge_info.name = nw_device bridge_info.phy_list = nw_phy_if new_nw_def = NwDef(nw_id,nw_type,nw_name,nw_desc,False,scope, bridge_info=bridge_info) else: # bridge_info = dynamic_map() bridge_info.name = nw_device ipv4_info = dynamic_map() ipv4_info.ip_network = nw_address_space # assign first address in the range to the # bridge ip = IP(nw_address_space) bridge_info.ip_address = ip[1].strNormal() bridge_info.netmask = ip.netmask().strNormal() dhcp_info = dynamic_map() r = nw_dhcp_range.split("-") if len(r) == 2: dhcp_info.dhcp_start = r[0].strip() dhcp_info.dhcp_end = r[1].strip() nat_info = dynamic_map() nat_info.interface = nw_nat_fwding new_nw_def = NwDef(nw_id,nw_type,nw_name,nw_desc,False,scope, bridge_info=bridge_info,ipv4_info=ipv4_info,dhcp_info=dhcp_info,nat_info=nat_info) #convert following parameters into dictionary object to save into network_definitions table. new_nw_def.bridge_info = self.get_dic(new_nw_def.bridge_info) new_nw_def.vlan_info = self.get_dic(new_nw_def.vlan_info) new_nw_def.bond_info = self.get_dic(new_nw_def.bond_info) new_nw_def.ipv4_info = self.get_dic(new_nw_def.ipv4_info) new_nw_def.dhcp_info = self.get_dic(new_nw_def.dhcp_info) new_nw_def.nat_info = self.get_dic(new_nw_def.nat_info) # manager = Basic.getGridManager() # group=manager.getGroup(pool_id) # print "pool_id==",pool_id,"node_id==",node_id errs = [] #Validations if scope == constants.SCOPE_S: alldefns = DBSession.query(ServerDefLink).filter_by(server_id = managed_node.id, def_type = to_unicode(constants.NETWORK)) elif scope == constants.SCOPE_SP: alldefns = DBSession.query(SPDefLink).filter_by(group_id = group_id, def_type = to_unicode(constants.NETWORK)) elif scope == constants.SCOPE_DC: alldefns = DBSession.query(DCDefLink).filter_by(site_id=site_id, def_type = to_unicode(constants.NETWORK)) for node_defn in alldefns: #Check for duplicate name rowNF = DBSession.query(NwDef).filter_by(id=node_defn.def_id, name=new_nw_def.name).first() if rowNF: return {'success':False,'msg':"Network definition with the same name already exists"} #raise Exception("Network definition with the same name already exists") #Check for address range rowNF = DBSession.query(NwDef).filter_by(id=node_defn.def_id).first() if rowNF: if new_nw_def.ipv4_info.get("ip_network") == rowNF.ipv4_info.get("ip_network"): return {'success':False,'msg':"Network definition with the same address space already exists"} #raise Exception("Network definition with the same address space already exists") errs = self.sync_manager.add_defn(new_nw_def, site, group, managed_node, auth, to_unicode(constants.NETWORK), constants.ATTACH, "ADD_NETWORK_DEF", self.nw_manager, self.manager, scope) if scope == constants.SCOPE_DC or scope == constants.SCOPE_SP: oos_count = 0 status = to_unicode(constants.IN_SYNC) details = None self.sync_manager.add_node_defn(managed_node.id, new_nw_def.id, to_unicode(constants.NETWORK), status, details, constants.SCOPE_S) op = constants.ATTACH update_status=True errs=[] self.nw_manager.sync_node_defn(managed_node, group_id, site_id, new_nw_def, to_unicode(constants.NETWORK), op, self.nw_manager, update_status, errs) if errs: if len(errs) > 0: add_mode=True self.sync_manager.remove_defn(new_nw_def, site, group, managed_node, auth, to_unicode(constants.NETWORK), constants.DETACH, "REMOVE_NETWORK_DEF", self.nw_manager, self.manager, add_mode, group_list, scope) return {'success':False,'msg':to_str(errs).replace("'","")} print "WEb New definition ",new_nw_def except Exception, ex: import traceback print print_traceback() print "Exception===",ex LOGGER.error(to_str(ex).replace("'","")) #if we get any exception while adding/ sync definition then are removing the definition. add_mode=True if new_nw_def: self.sync_manager.remove_defn(new_nw_def, site, group, managed_node, auth, to_unicode(constants.NETWORK), constants.DETACH, "REMOVE_NETWORK_DEF", self.nw_manager, self.manager, add_mode, group_list, scope) return {'success':False,'msg':to_str(ex).replace("'","")}
def exec_task(self, auth, ctx, image_id, config, mode, node_id, group_id,\ dom_id, vm_name): return NodeService().vm_config_settings(auth, image_id, config, mode, \ node_id, group_id, dom_id, vm_name)