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_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_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_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
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_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
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 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
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))
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 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)
