def calc_l3_subnetname(self, nuage_subnet): zone = vspk.NUZone(id=nuage_subnet.parent_id) zone.fetch() domain = vspk.NUDomain(id=zone.parent_id) domain.fetch() l3_name_format = self.cfg.get_l3_name_format() name = l3_name_format name = name.replace('$s', nuage_subnet.name) name = name.replace('$d', domain.name) name = name.replace('$z', zone.name) return name
def fetch(self): """ Do not fetch policy-group_templates :return: """ # Get object from database db = self.get_db() # Connect to Nuage db.login() # Load Nuage object nuage_pg = vsdk.NUDomain(id=self.id) # Fetch attribute if nuage_pg is not None: self.name = nuage_pg.name # Disconnect from Nuage db.logout()
def create(self): if self.nuage_domain_template is None: self._get_domain_template() self.nuage_object = vsdk.NUDomain(name=self.domain_name, template_id=self.nuage_domain_template.id, pat_enabled='DISABLED', ecmp_count=1, dhcp_behavior='CONSUME', fip_underlay=False, dpi='DISABLED', permitted_action='ALL', description=self.domain_desc, encryption='DISABLED', underlay_enabled='DISABLED', entity_scope='ENTERPRISE', stretched=False, multicast='DISABLED', tunnel_type='VXLAN', external_id=self.cms_name) self.nuage_enterprise.create_child(self.nuage_object) self._create_log()
api_url="https://portalproxy.lab.local") try: session.start() except: logging.error('Failed to start the session') return session.user # we assume we have the setup_logging() and start_csproot_session() methods # showed in the previous example from vspk import v5_0 as vspk setup_logging() csproot = start_csproot_session() # Create a new enterprise object. The only mandatory parameter is the name, # so we give it directly to the contructor new_enterprise = vspk.NUEnterprise(name="new-corp8") # Create the enterprise on VSD. csproot.create_child(new_enterprise) # Create a new domain object. new_domain = vspk.NUDomain() # The attributes can also be set on the object directly new_domain.name = "new-dom" #new_domain.template_id = "98088286-9bc5-4898-b5e5-ea7e8d99ff98" # Create the domain on VSD. new_enterprise.create_child(new_domain)
def main(): """ Main function to handle statistics """ # Handling arguments args = get_args() debug = args.debug log_file = None if args.logfile: log_file = args.logfile mode = args.mode nuage_enterprise = args.nuage_enterprise nuage_host = args.nuage_host nuage_port = args.nuage_port nuage_password = None if args.nuage_password: nuage_password = args.nuage_password nuage_username = args.nuage_username nosslcheck = args.nosslcheck verbose = args.verbose nuage_vm_enterprise = args.nuage_vm_enterprise nuage_vm_domain = None if args.nuage_vm_domain: nuage_vm_domain = args.nuage_vm_domain nuage_vm_zone = None if args.nuage_vm_zone: nuage_vm_zone = args.nuage_vm_zone nuage_vm_subnet = args.nuage_vm_subnet nuage_vm_user = None if args.nuage_vm_user: nuage_vm_user = args.nuage_vm_user vcenter_host = args.vcenter_host vcenter_port = args.vcenter_port vcenter_password = None if args.vcenter_password: vcenter_password = args.vcenter_password vcenter_username = args.vcenter_username vcenter_portgroup = args.vcenter_portgroup vcenter_vm = args.vcenter_vm # Logging settings if debug: log_level = logging.DEBUG elif verbose: log_level = logging.INFO else: log_level = logging.WARNING logging.basicConfig(filename=log_file, format='%(asctime)s %(levelname)s %(message)s', level=log_level) logger = logging.getLogger(__name__) # Disabling SSL verification if set ssl_context = None if nosslcheck: logger.debug('Disabling SSL certificate verification.') requests.packages.urllib3.disable_warnings() import ssl if hasattr(ssl, 'SSLContext'): ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1) ssl_context.verify_mode = ssl.CERT_NONE # Getting user password for Nuage connection if nuage_password is None: logger.debug( 'No command line Nuage password received, requesting Nuage password from user' ) nuage_password = getpass.getpass( prompt='Enter password for Nuage host %s for user %s: ' % (nuage_host, nuage_username)) # Getting user password for vCenter connection if vcenter_password is None: logger.debug( 'No command line vCenter password received, requesting vCenter password from user' ) vcenter_password = getpass.getpass( prompt='Enter password for vCenter host %s for user %s: ' % (vcenter_host, vcenter_username)) try: vc = None nc = None # Connecting to Nuage logger.info('Connecting to Nuage server %s:%s with username %s' % (nuage_host, nuage_port, nuage_username)) nc = vsdk.NUVSDSession(username=nuage_username, password=nuage_password, enterprise=nuage_enterprise, api_url="https://%s:%s" % (nuage_host, nuage_port)) nc.start() if not nc or not nc.is_current_session(): logger.error( 'Could not connect to Nuage host %s with user %s, enterprise %s and specified password' % (nuage_host, nuage_username, nuage_enterprise)) return 1 # Connecting to vCenter try: logger.info('Connecting to vCenter server %s:%s with username %s' % (vcenter_host, vcenter_port, vcenter_username)) if ssl_context: vc = SmartConnect(host=vcenter_host, user=vcenter_username, pwd=vcenter_password, port=int(vcenter_port), sslContext=ssl_context) else: vc = SmartConnect(host=vcenter_host, user=vcenter_username, pwd=vcenter_password, port=int(vcenter_port)) except IOError, e: pass if not vc: logger.error( 'Could not connect to vCenter host %s with user %s and specified password' % (vcenter_host, vcenter_username)) return 1 logger.info('Connected to both Nuage & vCenter servers') logger.debug('Registering vCenter disconnect at exit') atexit.register(Disconnect, vc) # Finding the Virtual Machine logger.debug('Searching for Virtual Machine: %s' % vcenter_vm) vc_vm = get_vcenter_object(logger, vc, [vim.VirtualMachine], vcenter_vm) if vc_vm is None: logger.critical('VM %s not found, ending run' % vcenter_vm) return 1 # Finding the Portgroup logger.debug('Searching for Distributed Portgroup %s' % vcenter_portgroup) vc_dvs_pg = get_vcenter_object(logger, vc, [vim.dvs.DistributedVirtualPortgroup], vcenter_portgroup) if vc_dvs_pg is None: logger.critical('Unknown distributed portgroup %s, exiting' % vcenter_portgroup) return 1 # Finding enterprise logger.debug('Searching for enterprise %s' % nuage_vm_enterprise) nc_enterprise = get_nuage_object(logger, nc.user, 'ENTERPRISE', 'name == "%s"' % nuage_vm_enterprise, True) if nc_enterprise is None: logger.critical('Unknown enterprise %s, exiting' % nuage_vm_enterprise) return 1 # Finding subnet logger.debug( 'Searching for the subnet, first by looking at the subnet itself.') nc_subnet = None nc_subnets = get_nuage_object(logger, nc.user, 'SUBNET', 'name == "%s"' % nuage_vm_subnet, False) if len(nc_subnets) == 1: logger.debug('Found the L3 subnet %s in Nuage' % nuage_vm_subnet) nc_subnet = nc_subnets[0] elif len(nc_subnets) == 0: logger.debug( 'Found no L3 subnet with name %s, checking L2 domains' % nuage_vm_subnet) nc_subnet = get_nuage_object(logger, nc_enterprise, 'L2DOMAIN', 'name == "%s"' % nuage_vm_subnet, True) elif len( nc_subnets ) > 1 and nuage_vm_domain is not None and nuage_vm_zone is not None: logger.debug( 'Found more than one L3 subnet with name %s, using Domain %s and Zone %s to find the right subnet' % (nuage_vm_subnet, nuage_vm_domain, nuage_vm_zone)) nc_domain = get_nuage_object(logger, nc_enterprise, 'DOMAIN', 'name == "%s"' % nuage_vm_domain, True) if nc_domain is None: logger.critical( 'Domain %s does not exist in Enterprise %s, exiting' % (nuage_vm_domain, nuage_vm_zone)) return 1 nc_zone = get_nuage_object(logger, nc_domain, 'ZONE', 'name == "%s"' % nuage_vm_zone, True) if nc_zone is None: logger.critical( 'Zone %s does not exist in Domain %s in Enterprise %s, exiting' % (nuage_vm_zone, nuage_vm_domain, nuage_vm_enterprise)) return 1 nc_subnet = get_nuage_object(logger, nc_zone, 'SUBNET', 'name == "%s"' % nuage_vm_subnet, False) if nc_subnet is None: logger.critical( 'Subnet with name %s does not exist as an L3 subnet or an L2 domain, exiting' ) return 1 # Getting VM UUID logger.debug('Getting VM UUID, MAC & IP') vc_vm_uuid = vc_vm.config.uuid logger.debug('Found UUID %s for VM %s' % (vc_vm_uuid, vcenter_vm)) vc_vm_net_info = vc_vm.guest.net vc_vm_mac = None vc_vm_ip = None for cur_net in vc_vm_net_info: if cur_net.macAddress: logger.debug('Mac address %s found for VM %s' % (cur_net.macAddress, vcenter_vm)) vc_vm_mac = cur_net.macAddress if vc_vm_mac and cur_net.ipConfig: if cur_net.ipConfig.ipAddress: for cur_ip in cur_net.ipConfig.ipAddress: logger.debug('Checking ip address %s for VM %s' % (cur_ip.ipAddress, vcenter_vm)) if re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', cur_ip.ipAddress ) and cur_ip.ipAddress != '127.0.0.1': vc_vm_ip = cur_ip.ipAddress break if vc_vm_mac and vc_vm_ip: logger.debug('Found MAC %s and IP %s for VM %s' % (vc_vm_mac, vc_vm_ip, vcenter_vm)) break # Check if IP is in subnet logger.debug('Verifying that IP %s of VM %s is part of subnet %s' % (vc_vm_ip, vcenter_vm, nuage_vm_subnet)) if not ipaddress.ip_address(unicode( vc_vm_ip, 'utf-8')) in ipaddress.ip_network( '%s/%s' % (nc_subnet.address, nc_subnet.netmask)): logger.critical('IP %s is not part of subnet %s with netmask %s' % (vc_vm_ip, nc_subnet.address, nc_subnet.netmask)) return 1 logger.info('Found UUID %s, MAC %s and IP %s for VM %s' % (vc_vm_uuid, vc_vm_mac, vc_vm_ip, vcenter_vm)) # if metadata mode, create metadata on the VM if mode.lower() == 'metadata': logger.debug('Setting the metadata on VM %s' % vcenter_vm) vm_option_values = [] # Network type vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.networktype', value='ipv4')) # User vm_option_values.append( vim.option.OptionValue(key='nuage.user', value=nuage_vm_user)) # IP vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.ip', value=vc_vm_ip)) if type(nc_subnet) is vsdk.NUSubnet: nc_zone = vsdk.NUZone(id=nc_subnet.parent_id) nc_zone.fetch() nc_domain = vsdk.NUDomain(id=nc_zone.parent_id) nc_domain.fetch() nc_enterprise = vsdk.NUEnterprise(id=nc_domain.parent_id) nc_enterprise.fetch() # Enterprise vm_option_values.append( vim.option.OptionValue(key='nuage.enterprise', value=nc_enterprise.name)) # Domain vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.domain', value=nc_domain.name)) # Zone vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.zone', value=nc_zone.name)) # Subnet vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.network', value=nc_subnet.name)) else: nc_enterprise = vsdk.NUEnterprise(id=nc_subnet.parent_id) nc_enterprise.fetch() # Enterprise vm_option_values.append( vim.option.OptionValue(key='nuage.enterprise', value=nc_enterprise.name)) # L2Domain vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.l2domain', value=nc_subnet.name)) logger.debug('Creating of config spec for VM') config_spec = vim.vm.ConfigSpec(extraConfig=vm_option_values) logger.info( 'Applying advanced parameters. This might take a couple of seconds' ) config_task = vc_vm.ReconfigVM_Task(spec=config_spec) logger.debug('Waiting for the advanced paramerter to be applied') run_loop = True while run_loop: info = config_task.info if info.state == vim.TaskInfo.State.success: logger.debug('Advanced parameters applied') run_loop = False break elif info.state == vim.TaskInfo.State.error: if info.error.fault: logger.info( 'Applying advanced parameters has quit with error: %s' % info.error.fault.faultMessage) else: logger.info( 'Applying advanced parameters has quit with cancelation' ) run_loop = False break sleep(1) # Else if mode split-activation, create vPort and VM elif mode.lower() == 'split-activation': # Creating vPort logger.debug('Creating vPort for VM %s' % vcenter_vm) nc_vport = vsdk.NUVPort( name=vcenter_vm, address_spoofing='INHERITED', type='VM', description='Automatically created, do not edit.') nc_subnet.create_child(nc_vport) # Creating VM logger.debug('Creating a Nuage VM for VM %s' % vcenter_vm) nc_vm = vsdk.NUVM(name=vcenter_vm, uuid=vc_vm_uuid, interfaces=[{ 'name': vcenter_vm, 'VPortID': nc_vport.id, 'MAC': vc_vm_mac, 'IPAddress': vc_vm_ip }]) nc.user.create_child(nc_vm) # Fetching nic from the VM logger.debug('Searching for NIC on VM %s' % vcenter_vm) vc_vm_nic = None for device in vc_vm.config.hardware.device: if isinstance(device, vim.vm.device.VirtualEthernetCard): logger.debug('Found NIC for VM %s' % vcenter_vm) vc_vm_nic = device break if vc_vm_nic is None: logger.critical('Could not find NIC for VM %s, exiting' % vcenter_vm) return 1 # Switching VM nic logger.debug('Creating spec to reconfigure the NIC of VM %s' % vcenter_vm) vc_nicspec = vim.vm.device.VirtualDeviceSpec() vc_nicspec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit vc_nicspec.device = vc_vm_nic vc_nicspec.device.wakeOnLanEnabled = True vc_nicspec.device.backing = vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo( ) vc_nicspec.device.backing.port = vim.dvs.PortConnection() vc_nicspec.device.backing.port.portgroupKey = vc_dvs_pg.key vc_nicspec.device.backing.port.switchUuid = vc_dvs_pg.config.distributedVirtualSwitch.uuid vc_nicspec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo( ) vc_nicspec.device.connectable.startConnected = True vc_nicspec.device.connectable.connected = True vc_nicspec.device.connectable.allowGuestControl = True vc_vm_nic_reconfig = vim.vm.ConfigSpec(deviceChange=[vc_nicspec]) logger.info( 'Applying NIC changes. This might take a couple of seconds') config_task = vc_vm.ReconfigVM_Task(spec=vc_vm_nic_reconfig) logger.debug('Waiting for the nic change to be applied') run_loop = True while run_loop: info = config_task.info if info.state == vim.TaskInfo.State.success: logger.debug('Nic change applied') run_loop = False break elif info.state == vim.TaskInfo.State.error: if info.error.fault: logger.info( 'Applying nic changes has quit with error: %s' % info.error.fault.faultMessage) else: logger.info( 'Applying nic changes has quit with cancelation') run_loop = False break sleep(1) logger.info( 'Succesfully attached VM %s to Nuage subnet %s, in mode %s' % (vcenter_vm, nuage_vm_subnet, mode))
def main(): # Handling arguments args = get_args() debug = args.debug verbose = args.verbose log_file = args.logfile nuage_organization = args.nuage_organization nuage_host = args.nuage_host nuage_port = args.nuage_port nuage_password = args.nuage_password nuage_username = args.nuage_username nuage_myEnterprise = args.nuage_myEnterprise nuage_myDomainTemplate = args.nuage_myDomainTemplate nuage_myDomain = args.nuage_myDomain nuage_myDomainDesc = args.nuage_myDomainDesc nuage_leaking = args.nuage_leaking MyCmsName = 'CMS-scripts' """ # Bouchonnage arguments debug = False verbose = False log_file = 'Nuage-log.txt' nuage_organization = 'TEST' nuage_host = '127.1.1.2' nuage_port = '8443' nuage_password = '******' nuage_username = '******' nuage_myEnterprise = 'TEST' nuage_myDomainTemplate = 'L3_PXY-RBD_FRT' nuage_myDomain = 'myTestDomain' nuage_myDomainDesc = 'DMZ TEST' """ # Logging settings logger = setup_logging(debug, verbose, log_file) # Getting user password for Nuage connection if nuage_password is None: logger.debug( 'No command line Nuage password received, requesting Nuage password from user' ) nuage_password = getpass.getpass( prompt='Enter password for Nuage host %s for user %s: ' % (nuage_host, nuage_username)) # Connection to VSD nc = start_nuage_connection(nuage_host, nuage_port, nuage_username, nuage_password, nuage_organization, logger) # Execute action myFilter = "name == \"" + nuage_myEnterprise + "\"" myEnterprise = nc.enterprises.get_first(filter=myFilter) print('Entreprise : %s' % myEnterprise.name) myFilter = "name == \"" + nuage_myDomainTemplate + "\"" myDomainTemplate = myEnterprise.domain_templates.get_first(filter=myFilter) print('Domain Template %s :' % (myDomainTemplate.name)) myNewDomain = vsdk.NUDomain(name=nuage_myDomain, template_id=myDomainTemplate.id, pat_enabled='DISABLED', ecmp_count=1, dhcp_behavior='CONSUME', fip_underlay=False, dpi='DISABLED', permitted_action='ALL', description=nuage_myDomainDesc, encryption='DISABLED', underlay_enabled='DISABLED', entity_scope='ENTERPRISE', stretched=False, multicast='DISABLED', tunnel_type='VXLAN', external_id=MyCmsName, leaking_enabled=nuage_leaking) print('L3Domain %s is created.' % (myNewDomain.name)) myEnterprise.create_child(myNewDomain) print('L3Domain %s id: %s' % (myNewDomain.name, myNewDomain.domain_id)) logger.warning('L3Domain %s id %s is created' % (myNewDomain.name, myNewDomain.domain_id))
def fetch(self): """ Fetch attribute from Nuage Discover children and then propagate fetch() on them Do not propagate fetch() on already known children in database :return: """ # Get object from database db = self.get_db() # Connect to Nuage db.login() # Load Nuage object if self.domain_type == "domain": nuage_domain = vsdk.NUDomain(id=self.id) elif self.domain_type == "l2domain": nuage_domain = vsdk.NUL2Domain(id=self.id) else: self.logger.error('NuageDomain::fetch: unknown domain_type: %s' % self.domain_type) raise RuntimeError("unknown domain_type %s" % self.domain_type) if nuage_domain is None: # Error handling : object doesn't exist anymore self.logger.error("%s::%s: unexpected object deletion." "Cause: object id=%s doesn't exist anymore in Nuage" % (__class__.__name__, __name__, self.id)) self.delete() return else: nuage_domain.fetch() # Fetch attribute self.name = nuage_domain.name # Discover domain_template if nuage_domain.template_id in db.children['domain_template'].keys(): # domain_template in db if nuage_domain.template_id in self.associated_objects['domain_template'].keys(): # domain_template already attached to policy group template pass else: # a domain can be attached to only one domain template for domain_template in self.domain_templates: self.detach(domain_template) self.assign(db.children['domain_template'][nuage_domain.template_id]) else: # unknown domain_template in db # launch a discovery on all database self.logger.info("%s::%s: unknown domain_template to assign: dom_id=%s; dom_id_tpl=%s" % (__class__.__name__, __name__, self.id, nuage_domain.template_id)) # fetch db.fetch() # Discover vPort for nuage_vport in nuage_domain.vports.get(): if nuage_vport.id in self.children['vport'].keys(): # known vport in db pass else: # unknown vport in db # if len(nuage_vport.policy_groups.get()) == 0: # # no policy group attached # self.logger.info("%s::%s: do not attach vport because no policy group is attached: " # "vport_id=%s; vport_name=%s; domain_id=%s; domain_name=%s" % # (__class__.__name__, __name__, # nuage_vport.id, nuage_vport.name,self.id, self.name)) # pass db_vport = NuageVPort(vsd_id=nuage_vport.id, vport_type=nuage_vport.type, logger=self.logger) # attach vPort to parent domain self.create_child(db_vport) # fetch recursively db_vport.fetch() # Discover NuagePolicyGroup for nuage_policy_group in nuage_domain.policy_groups.get(): # policy_group filter if (db.nuage_pg_filter is not None and db.nuage_pg_filter in nuage_policy_group.name) or \ db.nuage_pg_filter is None: if nuage_policy_group.id in self.children['policy_group'].keys(): # known policy_group in db pass else: # unknown policy_group in db # fetch recursively db_policy_group = NuagePolicyGroup(vsd_id=nuage_policy_group.id, logger=self.logger) self.create_child(db_policy_group) db_policy_group.fetch()