def create_new_vspk_session(): session = vspk.NUVSDSession( username='******', password='******', enterprise='csp', api_url=get_vsd_api_url()) session.start() return session
def nuage_login(user='******', password='******', org='csp', vsdhost='vsd.mydomain.com:8443'): session = vsdk.NUVSDSession(username=user, password=password, enterprise=org, api_url="https://" + vsdhost) try: logging.info('Establishing session to VSD %s as User %s', vsdhost, user) session.start() logging.info('Logged to VSD successfully') except: logging.error('Failed to start a Session to VSD') exit(-1) return session.user
def inspect_topology(username, password, enterprise, api_url): session = vsdk.NUVSDSession(username=username, password=password, enterprise=enterprise, api_url=api_url) session.start() user = session.user print("User:\n=====\nname: {0:s}, role: {1:s}".format( user.user_name, user.role)) print_items("\nEnterprises:\n============", user.enterprises.get(), name=True) print_items("\nDomains:\n========", user.domains.get(), name=True, description=True) print_items("\nL2Domains:\n==========", user.l2_domains.get(), name=True, description=True)
def main(): """ Manage the vCenter Integration Node configuration """ # Handling arguments args = get_args() debug = args.debug folder_name = None if args.folder: folder_name = args.folder log_file = None if args.logfile: log_file = args.logfile name = args.name 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 nuage_vm_enterprise = None if args.nuage_vm_enterprise: 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 = None if args.nuage_vm_subnet: nuage_vm_subnet = args.nuage_vm_subnet nuage_vm_ip = None if args.nuage_vm_ip: nuage_vm_ip = args.nuage_vm_ip nuage_vm_user = None if args.nuage_vm_user: nuage_vm_user = args.nuage_vm_user power_on = not args.nopoweron resource_pool_name = None if args.resource_pool: resource_pool_name = args.resource_pool nosslcheck = args.nosslcheck template = args.template 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 verbose = args.verbose # 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__) # 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 try: 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() except IOError: pass 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 nosslcheck: vc = SmartConnectNoSSL(host=vcenter_host, user=vcenter_username, pwd=vcenter_password, port=int(vcenter_port)) else: vc = SmartConnect(host=vcenter_host, user=vcenter_username, pwd=vcenter_password, port=int(vcenter_port)) except IOError: 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) # Verifying the Nuage Enterprise existence or selecting it if nuage_vm_enterprise: logger.debug('Finding Nuage enterprise %s' % nuage_vm_enterprise) vm_enterprise = nc.user.enterprises.get_first( filter="name == '%s'" % nuage_vm_enterprise) if vm_enterprise is None: logger.error('Unable to find Nuage enterprise %s' % nuage_vm_enterprise) return 1 logger.info('Nuage enterprise %s found' % nuage_vm_enterprise) else: clear(logger) print('Please select your enterprise:') index = 0 all_ent = nc.user.enterprises.get() for cur_ent in all_ent: print('%s. %s' % (index + 1, cur_ent.name)) index += 1 vm_enterprise = None while vm_enterprise is None: choice = eval( input( 'Please enter the number of the enterprise [1-%s]: ' % len(all_ent))) choice = int(choice) if choice > 0 and choice - 1 < len(all_ent): vm_enterprise = all_ent[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage User existence or selecting it if nuage_vm_user: logger.debug('Finding Nuage user %s' % nuage_vm_user) vm_user = vm_enterprise.users.get_first(filter="userName == '%s'" % nuage_vm_user) if vm_user is None: logger.error('Unable to find Nuage user %s' % nuage_vm_user) return 1 logger.info('Nuage user %s found' % nuage_vm_user) else: clear(logger) print('Enterprise: %s' % vm_enterprise.name) print(80 * '-') print('Please select your user:'******'%s. %s' % (index + 1, cur_user.user_name)) index += 1 vm_user = None while vm_user is None: choice = eval( input('Please enter the number of the user [1-%s]: ' % len(all_users))) choice = int(choice) if choice > 0 and choice - 1 < len(all_users): vm_user = all_users[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage Domain existence or selecting it if nuage_vm_domain: logger.debug('Finding Nuage domain %s' % nuage_vm_domain) vm_domain = vm_enterprise.domains.get_first(filter="name == '%s'" % nuage_vm_domain) if vm_domain is None: logger.error('Unable to find Nuage domain %s' % nuage_vm_domain) return 1 logger.info('Nuage domain %s found' % nuage_vm_domain) else: clear(logger) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) print(80 * '-') print('Please select your domain:') index = 0 all_dom = vm_enterprise.domains.get() for cur_dom in all_dom: print('%s. %s' % (index + 1, cur_dom.name)) index += 1 vm_domain = None while vm_domain is None: choice = eval( input('Please enter the number of the domain [1-%s]: ' % len(all_dom))) choice = int(choice) if choice > 0 and choice - 1 < len(all_dom): vm_domain = all_dom[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage Zone existence or selecting it if nuage_vm_zone: logger.debug('Finding Nuage zone %s' % nuage_vm_zone) vm_zone = vm_domain.zones.get_first(filter="name == '%s'" % nuage_vm_zone) if vm_zone is None: logger.error('Unable to find Nuage zone %s' % nuage_vm_zone) return 1 logger.info('Nuage zone %s found' % nuage_vm_zone) else: clear(logger) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) print('Domain: %s' % vm_domain.name) print(80 * '-') print('Please select your zone:') index = 0 all_zone = vm_domain.zones.get() for cur_zone in all_zone: print('%s. %s' % (index + 1, cur_zone.name)) index += 1 vm_zone = None while vm_zone is None: choice = eval( input('Please enter the number of the zone [1-%s]: ' % len(all_zone))) choice = int(choice) if choice > 0 and choice - 1 < len(all_zone): vm_zone = all_zone[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage Subnet existence or selecting it if nuage_vm_subnet: logger.debug('Finding Nuage subnet %s' % nuage_vm_subnet) vm_subnet = vm_zone.subnets.get_first(filter="name == '%s'" % nuage_vm_subnet) if vm_subnet is None: logger.error('Unable to find Nuage subnet %s' % nuage_vm_subnet) return 1 logger.info('Nuage subnet %s found' % nuage_vm_subnet) else: clear(logger) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) print('Domain: %s' % vm_domain.name) print('Zone: %s' % vm_zone.name) print(80 * '-') print('Please select your subnet:') index = 0 all_subnet = vm_zone.subnets.get() for cur_subnet in all_subnet: print('%s. %s - %s/%s' % (index + 1, cur_subnet.name, cur_subnet.address, cur_subnet.netmask)) index += 1 vm_subnet = None while vm_subnet is None: choice = eval( input('Please enter the number of the subnet [1-%s]: ' % len(all_subnet))) choice = int(choice) if choice > 0 and choice - 1 < len(all_subnet): vm_subnet = all_subnet[choice - 1] break print('Invalid choice, please try again') # Verifying the IP or asking for it if nuage_vm_ip: logger.debug('Verifying if IP %s is inside Nuage subnet %s range' % (nuage_vm_ip, vm_subnet.name)) if not ipaddress.ip_address(nuage_vm_ip) in ipaddress.ip_network( '%s/%s' % (vm_subnet.address, vm_subnet.netmask)): logger.error( 'IP %s is not part of subnet %s with netmask %s' % (nuage_vm_ip, vm_subnet.address, vm_subnet.netmask)) return 1 vm_ip = nuage_vm_ip else: clear(logger) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) print('Domain: %s' % vm_domain.name) print('Zone: %s' % vm_zone.name) print('Subnet: %s - %s/%s' % (vm_subnet.name, vm_subnet.address, vm_subnet.netmask)) print(80 * '-') print( 'If you want a static IP, please enter it. Or press enter for a DHCP assigned IP.' ) vm_ip = None while vm_ip is None: choice = eval( input( 'Please enter the IP or press enter for a DHCP assigned IP: ' )) if not choice or ipaddress.ip_address( choice) in ipaddress.ip_network( '%s/%s' % (vm_subnet.address, vm_subnet.netmask)): vm_ip = choice break print('Invalid choice, please try again') logger.info('Using following Nuage values:') logger.info('Enterprise: %s' % vm_enterprise.name) logger.info('User: %s' % vm_user.user_name) logger.info('Domain: %s' % vm_domain.name) logger.info('Zone: %s' % vm_zone.name) logger.info('Subnet: %s - %s/%s' % (vm_subnet.name, vm_subnet.address, vm_subnet.netmask)) if vm_ip: logger.info('Static IP: %s' % vm_ip) # Find the correct VM logger.debug('Finding template %s' % template) template_vm = find_vm(vc, logger, template) if template_vm is None: logger.error('Unable to find template %s' % template) return 1 logger.info('Template %s found' % template) # Find the correct Resource Pool resource_pool = None if resource_pool_name is not None: logger.debug('Finding resource pool %s' % resource_pool_name) resource_pool = find_resource_pool(vc, logger, resource_pool_name) if resource_pool is None: logger.critical('Unable to find resource pool %s' % resource_pool_name) return 1 logger.info('Resource pool %s found' % resource_pool_name) # Find the correct folder folder = None if folder_name is not None: logger.debug('Finding folder %s' % folder_name) folder = find_folder(vc, logger, folder_name) if folder is None: logger.critical('Unable to find folder %s' % folder_name) return 1 logger.info('Folder %s found' % folder_name) else: logger.info('Setting folder to template folder as default') folder = template_vm.parent # Creating necessary specs logger.debug('Creating relocate spec') if resource_pool is not None: logger.debug('Resource pool found, using') relocate_spec = vim.vm.RelocateSpec(pool=resource_pool) else: logger.debug('No resource pool found, continuing without it') relocate_spec = vim.vm.RelocateSpec() logger.debug('Creating clone spec') clone_spec = vim.vm.CloneSpec(powerOn=False, template=False, location=relocate_spec) run_loop = True vm = None logger.info('Trying to clone %s to new virtual machine' % template) if find_vm(vc, logger, name): logger.warning('Virtual machine already exists, not creating') run_loop = False else: logger.debug('Creating clone task') task = template_vm.Clone(name=name, folder=folder, spec=clone_spec) logger.info('Cloning task created') logger.info( 'Checking task for completion. This might take a while') while run_loop: info = task.info logger.debug('Checking clone task') if info.state == vim.TaskInfo.State.success: logger.info('Cloned and running') vm = info.result run_loop = False break elif info.state == vim.TaskInfo.State.running: logger.debug('Cloning task is at %s percent' % info.progress) elif info.state == vim.TaskInfo.State.queued: logger.debug('Cloning task is queued') elif info.state == vim.TaskInfo.State.error: if info.error.fault: logger.info('Cloning task has quit with error: %s' % info.error.fault.faultMessage) else: logger.info('Cloning task has quit with cancelation') run_loop = False break logger.debug('Sleeping 10 seconds for new check') sleep(10) # If the VM does not exist, cloning failed and the script is terminated if not vm: logger.error('Clone failed') return 1 # Setting Nuage metadata logger.info('Setting Nuage Metadata') vm_option_values = [] # Enterprise vm_option_values.append( vim.option.OptionValue(key='nuage.enterprise', value=vm_enterprise.name)) # Domain vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.domain', value=vm_domain.name)) # Zone vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.zone', value=vm_zone.name)) # Subnet vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.network', value=vm_subnet.name)) # 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=vm_user.user_name)) # IP if vm_ip: vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.ip', value=vm_ip)) 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 = 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(5) if power_on: logger.info('Powering on VM. This might take a couple of seconds') power_on_task = vm.PowerOn() logger.debug('Waiting fo VM to power on') run_loop = True while run_loop: info = power_on_task.info if info.state == vim.TaskInfo.State.success: run_loop = False break elif info.state == vim.TaskInfo.State.error: if info.error.fault: logger.info('Power on has quit with error: %s' % info.error.fault.faultMessage) else: logger.info('Power on has quit with cancelation') run_loop = False break sleep(5) except vmodl.MethodFault as e: logger.critical('Caught vmodl fault: %s' % e.msg) return 1 except Exception as e: logger.critical('Caught exception: %s' % str(e)) return 1
def main(): """ Main function to handle statistics """ # Handling arguments args = get_args() debug = args.debug entity_type = args.entity_type json_output = args.json_output log_file = None if args.logfile: log_file = args.logfile entity_name = None if args.entity_name: entity_name = args.entity_name 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 statistic_types = statistics_valid_types if args.statistic_types: statistic_types = args.statistic_types # nosslcheck = args.nosslcheck time_difference = args.time_difference verbose = args.verbose # 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__) # Validating time_difference input time_check = re.compile('^([0-9]+)([m|h|d]?)$') time_matches = time_check.match(time_difference) if time_matches is None: logger.critical('The time indication %s is an invalid value, exiting' % time_difference) return 1 time_diff = int(float(time_matches.group(1))) if time_matches.group(2) == 'm': logger.debug( 'Found m in the time difference, multiplying integer by 60') time_diff *= 60 elif time_matches.group(2) == 'h': logger.debug( 'Found h in the time difference, multiplying integer by 3600') time_diff *= 3600 elif time_matches.group(2) == 'd': logger.debug( 'Found d in the time difference, multiplying integer by 86400') time_diff *= 86400 logger.debug('Time difference set to %s seconds' % time_diff) # 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)) try: # 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() except Exception as e: logger.error( 'Could not connect to Nuage host %s with user %s and specified password' % (nuage_host, nuage_username)) logger.critical('Caught exception: %s' % str(e)) return 1 # Getting entities & defining output fields output_type = None entities = [] output_type = entity_type.capitalize() search_query = 'name == "%s"' % entity_name if entity_name else None logger.debug('Getting %ss matching the search' % output_type) entities = nc.user.fetcher_for_rest_name( entity_type.lower()).get(filter=search_query) if entity_type == 'VM' and entities: vms = entities entities = [] for vm in vms: for vm_interface in vm.vm_interfaces.get(): entities.append(vm_interface) # Filling output fields output_fields = [ output_type, 'Start timestamp', 'End timestamp', 'Start date/time', 'End date/time', '# datapoints' ] output_fields.extend(statistic_types) # Verifying if there are enities if len(entities) == 0: logger.critical('No matching entities found of type %s' % entity_type) return 1 # Starting output if json_output: logger.debug('JSON output enabled, not setting up an output table') json_object = [] else: logger.debug('Setting up output table') pt = PrettyTable(output_fields) # Setting general values stat_end_time = int(time.time()) stat_start_time = int(stat_end_time - time_diff) stat_metric_types_str = ','.join(statistic_types) entity_data_freq = 60 for entity in entities: if entity_type != 'VM' and 'BackHaul' in entity.name: logger.debug('Found a BackHaul %s, skipping' % output_type) continue # Getting stats collection frequency if entity_type != 'VM': logger.debug('Looking for a statistics policy on %s %s' % (output_type, entity.name)) entity_stat_policies = entity.statistics_policies.get() if len(entity_stat_policies) > 0: logger.debug( 'Found at least one statistics policy on %s %s, getting data collection frequency' % (output_type, entity.name)) entity_data_freq = entity_stat_policies[ 0].data_collection_frequency logger.debug('Data collection frequency for %s %s saved as %s' % (output_type, entity.name, entity_data_freq)) num_data_points = int(old_div(time_diff, entity_data_freq)) # Collecting statistics logger.debug( 'Collecting %s datapoints of statistics %s on %s %s from timestamp %s to timestamp %s' % (num_data_points, stat_metric_types_str, output_type, entity.name, stat_start_time, stat_end_time)) stats_data = entity.statistics.get_first( query_parameters={ 'startTime': stat_start_time, 'endTime': stat_end_time, 'numberOfDataPoints': num_data_points, 'metricTypes': stat_metric_types_str }).stats_data # Determining name output_name = entity.name if entity_type == "VM": output_name = '%s %s' % (entity.parent.name, entity.mac) # Generating output row if json_output: json_dict = { output_type: output_name, 'Start timestamp': stat_start_time, 'End timestamp': stat_end_time, 'Start date/time': datetime.datetime.fromtimestamp(stat_start_time).strftime( '%Y-%m-%d %H:%M:%S'), 'End date/time': datetime.datetime.fromtimestamp(stat_end_time).strftime( '%Y-%m-%d %H:%M:%S'), '# datapoints': num_data_points } json_dict.update(stats_data) json_object.append(json_dict) else: row = [ output_name, stat_start_time, stat_end_time, datetime.datetime.fromtimestamp(stat_start_time).strftime( '%Y-%m-%d %H:%M:%S'), datetime.datetime.fromtimestamp(stat_end_time).strftime( '%Y-%m-%d %H:%M:%S'), num_data_points ] for statistic_type in statistic_types: row.append(stats_data[statistic_type]) pt.add_row(row) logger.debug('Printing output') if json_output: print(json.dumps(json_object, sort_keys=True, indent=4)) else: print(pt.get_string()) return 0
def main(): args = get_args() ip = args.ip[0] debug = args.debug verbose = args.verbose # Logging settings if debug: log_level = logging.DEBUG elif verbose: log_level = logging.INFO else: log_level = logging.WARNING logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=log_level) logger = logging.getLogger(__name__) nc = None # Connecting to Nuage try: logger.info('Connecting to Nuage server %s as csproot' % ip) nc = vsdk.NUVSDSession(username=u'csproot', password=u'csproot', enterprise=u'csp', api_url=u'https://%s:8443' % ip) nc.start() except IOError: pass if not nc or not nc.is_current_session(): logger.error('Could not connect to Nuage host %s with user csproot' % ip) return 1 logger.info('Connected to Nuage') for vcenter in nc.user.vcenters.get(): logger.info("Checking values on vCenter %s" % vcenter.name) replace_interfaces(logger, vcenter) for datacenter in vcenter.vcenter_data_centers.get(): logger.info("Checking values on datacenter %s" % datacenter.name) replace_interfaces(logger, datacenter) for hypervisor in datacenter.vcenter_hypervisors.get(): logger.info("Checking values for standalone hypervisor %s" % hypervisor.name) replace_interfaces(logger, hypervisor) for cluster in datacenter.vcenter_clusters.get(): logger.info("Checking values for cluster %s" % cluster.name) replace_interfaces(logger, cluster) for hypervisor in cluster.vcenter_hypervisors.get(): logger.info("Checking values for hypervisor %s" % hypervisor.name) replace_interfaces(logger, hypervisor) return 0
def main(): """ Manage the activation of a vSphere VM """ # Handling arguments args = get_args() if args.config_file: cfg = parse_config(args.config_file) elif os.path.isfile('{0:s}/.nuage/config.ini'.format(os.path.expanduser('~'))): cfg = parse_config('{0:s}/.nuage/config.ini'.format(os.path.expanduser('~'))) else: print('Missing config file') return 1 mode = args.mode nuage_vm_enterprise = None if args.nuage_vm_enterprise: 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 = None if args.nuage_vm_subnet: nuage_vm_subnet = args.nuage_vm_subnet nuage_vm_ip = None if args.nuage_vm_ip: nuage_vm_ip = args.nuage_vm_ip nuage_vm_user = None if args.nuage_vm_user: nuage_vm_user = args.nuage_vm_user nuage_vm_policy_group = None if args.nuage_vm_policy_group: nuage_vm_user = args.nuage_vm_policy_group nuage_vm_redirection_target = None if args.nuage_vm_redirection_target: nuage_vm_user = args.nuage_vm_redirection_target vcenter_vm_name = None if args.vcenter_vm_name: vcenter_vm_name = args.vcenter_vm_name # Handling logging log_dir = cfg.get('LOG', 'directory') log_file = cfg.get('LOG', 'file') log_level = cfg.get('LOG', 'level') if not log_level: log_level = 'ERROR' log_path = None if log_dir and log_file and os.path.isdir(log_dir) and os.access(log_dir, os.W_OK): log_path = os.path.join(log_dir, log_file) logging.basicConfig(filename=log_path, format='%(asctime)s %(levelname)s - %(name)s - %(message)s', level=log_level) logging.info('Logging initiated') try: vc = None nc = None # Connecting to Nuage try: logging.info('Connecting to Nuage server {0:s} with username {1:s} and enterprise {2:s}'.format( cfg.get('NUAGE', 'vsd_api_url'), cfg.get('NUAGE', 'vsd_api_user'), cfg.get('NUAGE', 'vsd_api_enterprise'))) nc = vsdk.NUVSDSession(username=cfg.get('NUAGE', 'vsd_api_user'), password=cfg.get('NUAGE', 'vsd_api_password'), enterprise=cfg.get('NUAGE', 'vsd_api_enterprise'), api_url=cfg.get('NUAGE', 'vsd_api_url')) nc.start() except IOError: pass if not nc or not nc.is_current_session(): logging.error( 'Could not connect to Nuage host {0:s} with user {1:s}, enterprise {2:s} and specified password'.format( cfg.get('NUAGE', 'vsd_api_url'), cfg.get('NUAGE', 'vsd_api_user'), cfg.get('NUAGE', 'vsd_api_enterprise'))) return 1 # Connecting to vCenter try: logging.info( 'Connecting to vCenter server {0:s} with username {1:s}'.format(cfg.get('VSPHERE', 'vsphere_api_host'), cfg.get('VSPHERE', 'vsphere_api_user'))) vc = SmartConnectNoSSL(host=cfg.get('VSPHERE', 'vsphere_api_host'), user=cfg.get('VSPHERE', 'vsphere_api_user'), pwd=cfg.get('VSPHERE', 'vsphere_api_password'), port=int(cfg.get('VSPHERE', 'vsphere_api_port'))) except IOError: pass if not vc: logging.error('Could not connect to vCenter host {0:s} with user {1:s} and specified password'.format( cfg.get('VSPHERE', 'vsphere_api_host'), cfg.get('VSPHERE', 'vsphere_api_user'))) return 1 logging.info('Connected to both Nuage & vCenter servers') logging.debug('Registering vCenter disconnect at exit') atexit.register(Disconnect, vc) vcenter_vm = None vm_enterprise = None vm_user = None vm_domain = None vm_is_l2domain = False vm_zone = None vm_subnet = None vm_ip = None vm_policy_group = None vm_redirection_target = None # Verifying the vCenter VM existence or selecting it if vcenter_vm_name: vcenter_vm = find_vm(vc, vcenter_vm_name) if vcenter_vm is None: logging.critical('Unable to find specified VM with name {0:s}'.format(vcenter_vm_name)) return 1 else: logging.debug('Offering a choice of which VM to activate') content = vc.content obj_view = content.viewManager.CreateContainerView(content.rootFolder, [vim.VirtualMachine], True) vm_list = obj_view.view clear() print('Please select your VM:') index = 0 for cur_vm in vm_list: print('%s. %s' % (index + 1, cur_vm.name)) index += 1 while vcenter_vm is None: choice = eval(input('Please enter the number of the VM [1-%s]: ' % len(vm_list))) choice = int(choice) if choice > 0 and choice - 1 < len(vm_list): vcenter_vm = vm_list[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage Enterprise existence or selecting it if nuage_vm_enterprise: logging.debug('Finding Nuage enterprise %s' % nuage_vm_enterprise) vm_enterprise = nc.user.enterprises.get_first(filter="name == '%s'" % nuage_vm_enterprise) if vm_enterprise is None: logging.error('Unable to find Nuage enterprise %s' % nuage_vm_enterprise) return 1 logging.info('Nuage enterprise %s found' % nuage_vm_enterprise) else: clear() print('VM: %s' % vcenter_vm.name) print(80 * '-') print('Please select your enterprise:') index = 0 all_ent = nc.user.enterprises.get() for cur_ent in all_ent: print('%s. %s' % (index + 1, cur_ent.name)) index += 1 while vm_enterprise is None: choice = eval(input('Please enter the number of the enterprise [1-%s]: ' % len(all_ent))) choice = int(choice) if choice > 0 and choice - 1 < len(all_ent): vm_enterprise = all_ent[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage User existence or selecting it if nuage_vm_user: logging.debug('Finding Nuage user %s' % nuage_vm_user) vm_user = vm_enterprise.users.get_first(filter="userName == '%s'" % nuage_vm_user) if vm_user is None: logging.error('Unable to find Nuage user %s' % nuage_vm_user) return 1 logging.info('Nuage user %s found' % nuage_vm_user) else: clear() print('VM: %s' % vcenter_vm.name) print('Enterprise: %s' % vm_enterprise.name) print(80 * '-') print('Please select your user:'******'%s. %s' % (index + 1, cur_user.user_name)) index += 1 while vm_user is None: choice = eval(input('Please enter the number of the user [1-%s]: ' % len(all_users))) choice = int(choice) if choice > 0 and choice - 1 < len(all_users): vm_user = all_users[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage Domain existence or selecting it if nuage_vm_domain: logging.debug('Finding Nuage domain %s' % nuage_vm_domain) vm_domain = vm_enterprise.domains.get_first(filter="name == '%s'" % nuage_vm_domain) if vm_domain is None: logging.debug('Unable to find the domain {0:s} as an L3 domain'.format(nuage_vm_domain)) vm_domain = vm_enterprise.l2_domains.get_first(filter="name == '%s'" % nuage_vm_domain) vm_is_l2domain = True if vm_domain is None: logging.error('Unable to find Nuage domain {0:s}'.format(nuage_vm_domain)) return 1 logging.info('Nuage domain %s found' % nuage_vm_domain) else: clear() print('VM: %s' % vcenter_vm.name) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) print(80 * '-') print('Please select your domain:') index = 0 all_l3_dom = vm_enterprise.domains.get() all_l2_dom = vm_enterprise.l2_domains.get() all_dom = all_l2_dom + all_l3_dom for cur_dom in all_l2_dom: print('%s. L2 %s - %s/%s' % (index + 1, cur_dom.name, cur_dom.address, cur_dom.netmask)) index += 1 for cur_dom in all_l3_dom: print('%s. L3 - %s' % (index + 1, cur_dom.name)) index += 1 while vm_domain is None: choice = eval(input('Please enter the number of the domain [1-%s]: ' % len(all_dom))) choice = int(choice) if choice > 0 and choice - 1 < len(all_dom): vm_domain = all_dom[choice - 1] if type(vm_domain) is vsdk.NUL2Domain: vm_is_l2domain = True break print('Invalid choice, please try again') # Verifying the Nuage Zone existence or selecting it if not vm_is_l2domain and nuage_vm_zone: logging.debug('Finding Nuage zone %s' % nuage_vm_zone) vm_zone = vm_domain.zones.get_first(filter="name == '%s'" % nuage_vm_zone) if vm_zone is None: logging.error('Unable to find Nuage zone %s' % nuage_vm_zone) return 1 logging.info('Nuage zone %s found' % nuage_vm_zone) elif not vm_is_l2domain: clear() print('VM: %s' % vcenter_vm.name) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) print('Domain: %s' % vm_domain.name) print(80 * '-') print('Please select your zone:') index = 0 all_zone = vm_domain.zones.get() for cur_zone in all_zone: print('%s. %s' % (index + 1, cur_zone.name)) index += 1 while vm_zone is None: choice = eval(input('Please enter the number of the zone [1-%s]: ' % len(all_zone))) choice = int(choice) if choice > 0 and choice - 1 < len(all_zone): vm_zone = all_zone[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage Subnet existence or selecting it if not vm_is_l2domain and nuage_vm_subnet: logging.debug('Finding Nuage subnet %s' % nuage_vm_subnet) vm_subnet = vm_zone.subnets.get_first(filter="name == '%s'" % nuage_vm_subnet) if vm_subnet is None: logging.error('Unable to find Nuage subnet %s' % nuage_vm_subnet) return 1 logging.info('Nuage subnet %s found' % nuage_vm_subnet) elif not vm_is_l2domain: clear() print('VM: %s' % vcenter_vm.name) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) print('Domain: %s' % vm_domain.name) print('Zone: %s' % vm_zone.name) print(80 * '-') print('Please select your subnet:') index = 0 all_subnet = vm_zone.subnets.get() for cur_subnet in all_subnet: print('%s. %s - %s/%s' % (index + 1, cur_subnet.name, cur_subnet.address, cur_subnet.netmask)) index += 1 while vm_subnet is None: choice = eval(input('Please enter the number of the subnet [1-%s]: ' % len(all_subnet))) choice = int(choice) if choice > 0 and choice - 1 < len(all_subnet): vm_subnet = all_subnet[choice - 1] break print('Invalid choice, please try again') # Verifying the IP or asking for it if nuage_vm_ip: logging.debug('Verifying if IP %s is inside Nuage subnet %s range' % (nuage_vm_ip, vm_subnet.name)) if not ipaddress.ip_address(nuage_vm_ip) in ipaddress.ip_network('%s/%s' % (vm_subnet.address, vm_subnet.netmask)): logging.error('IP %s is not part of subnet %s with netmask %s' % (nuage_vm_ip, vm_subnet.address, vm_subnet.netmask)) return 1 vm_ip = nuage_vm_ip else: clear() print('VM: %s' % vcenter_vm.name) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) if not vm_is_l2domain: print('Domain: %s' % vm_domain.name) print('Zone: %s' % vm_zone.name) print('Subnet: %s - %s/%s' % (vm_subnet.name, vm_subnet.address, vm_subnet.netmask)) else: print('Domain: %s - %s/%s' % (vm_domain.name, vm_domain.address, vm_domain.netmask)) print(80 * '-') print('If you want a static IP, please enter it. Or press enter for a DHCP assigned IP.') while vm_ip is None: choice = eval(input('Please enter the IP or press enter for a DHCP assigned IP: ')) if not choice or ipaddress.ip_address(choice) in ipaddress.ip_network( '%s/%s' % (vm_subnet.address, vm_subnet.netmask)): vm_ip = choice break print('Invalid choice, please try again') # Verifying the Nuage policy group existence or selecting it if nuage_vm_policy_group: logging.debug('Finding Nuage policy group %s' % nuage_vm_policy_group) vm_policy_group = vm_domain.policy_groups.get_first(filter="name == '%s'" % nuage_vm_policy_group) if vm_policy_group is None: logging.error('Unable to find Nuage policy group {0:s}'.format(nuage_vm_policy_group)) return 1 logging.info('Nuage policy group %s found' % nuage_vm_policy_group) else: clear() print('VM: %s' % vcenter_vm.name) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) if not vm_is_l2domain: print('Domain: %s' % vm_domain.name) print('Zone: %s' % vm_zone.name) print('Subnet: %s - %s/%s' % (vm_subnet.name, vm_subnet.address, vm_subnet.netmask)) else: print('Domain: %s - %s/%s' % (vm_domain.name, vm_domain.address, vm_domain.netmask)) if vm_ip: print('IP: {0:s}'.format(vm_ip)) print(80 * '-') print('Please select your policy group:') index = 0 all_pg = vm_domain.policy_groups.get() print('0. None') for cur_pg in all_pg: print('%s. %s' % (index + 1, cur_pg.name)) index += 1 while vm_policy_group is None: choice = eval(input('Please enter the number of the policy group [0-%s]: ' % len(all_pg))) choice = int(choice) if choice == 0: vm_policy_group = None break elif choice > 0 and choice - 1 < len(all_pg): vm_policy_group = all_pg[choice - 1] break print('Invalid choice, please try again') # Verifying the Nuage redirection target existence or selecting it if nuage_vm_redirection_target: logging.debug('Finding Nuage redirection target %s' % nuage_vm_redirection_target) vm_redirection_target = vm_domain.redirection_targets.get_first( filter="name == '%s'" % nuage_vm_redirection_target) if vm_redirection_target is None: logging.error('Unable to find Nuage redirection target {0:s}'.format(nuage_vm_redirection_target)) return 1 logging.info('Nuage redirection target %s found' % nuage_vm_redirection_target) else: clear() print('VM: %s' % vcenter_vm.name) print('Enterprise: %s' % vm_enterprise.name) print('User: %s' % vm_user.user_name) if not vm_is_l2domain: print('Domain: %s' % vm_domain.name) print('Zone: %s' % vm_zone.name) print('Subnet: %s - %s/%s' % (vm_subnet.name, vm_subnet.address, vm_subnet.netmask)) else: print('Domain: %s - %s/%s' % (vm_domain.name, vm_domain.address, vm_domain.netmask)) if vm_ip: print('IP: {0:s}'.format(vm_ip)) if vm_policy_group: print('Policy group: {0:s}'.format(vm_policy_group.name)) print(80 * '-') print('Please select your redirection target:') index = 0 all_rt = vm_domain.redirection_targets.get() print('0. None') for cur_rt in all_rt: print('%s. %s' % (index + 1, cur_rt.name)) index += 1 while vm_redirection_target is None: choice = eval(input('Please enter the number of the redirection target [0-%s]: ' % len(all_rt))) choice = int(choice) if choice == 0: vm_redirection_target = None break elif choice > 0 and choice - 1 < len(all_rt): vm_redirection_target = all_rt[choice - 1] break print('Invalid choice, please try again') logging.info('Using following Nuage values:') logging.info('Enterprise: %s' % vm_enterprise.name) logging.info('User: %s' % vm_user.user_name) if not vm_is_l2domain: logging.info('Domain: %s' % vm_domain.name) logging.info('Zone: %s' % vm_zone.name) logging.info('Subnet: %s - %s/%s' % (vm_subnet.name, vm_subnet.address, vm_subnet.netmask)) else: logging.info('Domain: %s - %s/%s' % (vm_domain.name, vm_domain.address, vm_domain.netmask)) if vm_ip: logging.info('Static IP: %s' % vm_ip) if vm_policy_group: logging.info('Policy group: {0:s}'.format(vm_policy_group.name)) if vm_redirection_target: logging.info('Redirection target: {0:s}'.format(vm_redirection_target.name)) clear() if mode == 'metadata': print('Setting Nuage Metadata on VM') # Setting Nuage metadata logging.info('Setting Nuage Metadata') vm_option_values = [] # Enterprise vm_option_values.append(vim.option.OptionValue(key='nuage.enterprise', value=vm_enterprise.name)) if vm_is_l2domain: # L2 Domain vm_option_values.append(vim.option.OptionValue(key='nuage.nic0.l2domain', value=vm_domain.name)) else: # Domain vm_option_values.append(vim.option.OptionValue(key='nuage.nic0.domain', value=vm_domain.name)) # Zone vm_option_values.append(vim.option.OptionValue(key='nuage.nic0.zone', value=vm_zone.name)) # Subnet vm_option_values.append(vim.option.OptionValue(key='nuage.nic0.network', value=vm_subnet.name)) # 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=vm_user.user_name)) # IP if vm_ip: vm_option_values.append(vim.option.OptionValue(key='nuage.nic0.ip', value=vm_ip)) # Policy group if vm_policy_group: vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.policy-group', value=vm_policy_group.name)) # Redirection target if vm_redirection_target: vm_option_values.append( vim.option.OptionValue(key='nuage.nic0.redirection-target', value=vm_redirection_target.name)) logging.debug('Creating of config spec for VM') config_spec = vim.vm.ConfigSpec(extraConfig=vm_option_values) logging.info('Applying advanced parameters. This might take a couple of seconds') config_task = vcenter_vm.ReconfigVM_Task(spec=config_spec) logging.debug('Waiting for the advanced paramerter to be applied') while True: info = config_task.info if info.state == vim.TaskInfo.State.success: logging.debug('Advanced parameters applied') break elif info.state == vim.TaskInfo.State.error: if info.error.fault: logging.info( 'Applying advanced parameters has quit with error: %s' % info.error.fault.faultMessage) else: logging.info('Applying advanced parameters has quit with cancelation') break sleep(5) elif mode == 'split-activation': print('Creating vPort and VM in VSD for split activation') logging.debug('Starting split activation') # Getting VM UUID logging.debug('Getting VM UUID, MAC & IP') vcenter_vm_uuid = vcenter_vm.config.uuid logging.debug('Found UUID %s for VM %s' % (vcenter_vm_uuid, vcenter_vm.name)) vcenter_vm_mac = None vcenter_vm_hw = vcenter_vm.config.hardware for dev in vcenter_vm_hw.device: if isinstance(dev, vim.vm.device.VirtualEthernetCard): if dev.macAddress: logging.debug('Found MAC {0:s} for VM {1:s}'.format(dev.macAddress, vcenter_vm.name)) vcenter_vm_mac = dev.macAddress break if vcenter_vm_mac is None: logging.critical('Unable to find a valid mac address for VM') return 1 # Creating vPort logging.debug('Creating vPort for VM %s' % vcenter_vm.name) nc_vport = vsdk.NUVPort(name='{0:s}-vport'.format(vcenter_vm.name), address_spoofing='INHERITED', type='VM', description='Automatically created, do not edit.') if vm_is_l2domain: vm_domain.create_child(nc_vport) else: vm_subnet.create_child(nc_vport) # Creating VM logging.debug('Creating a Nuage VM for VM %s' % vcenter_vm) nc_vm = vsdk.NUVM(name=vcenter_vm.name, uuid=vcenter_vm_uuid, interfaces=[{ 'name': vcenter_vm_mac, 'VPortID': nc_vport.id, 'MAC': vcenter_vm_mac }]) nc.user.create_child(nc_vm) else: logging.critical('Invalid mode') return 1 except vmodl.MethodFault as e: logging.critical('Caught vmodl fault: {0:s}'.format(e.msg)) return 1 except Exception as e: logging.critical('Caught exception: {0:s}'.format(str(e))) return 1 print('Activation of VM finished')
def main(): """ Main function to handle vcenter vm names and the mapping to a policy group """ global logger, configuration, nc, nc_enterprise, nc_domain, nc_subnetmap, nc_policygroupmap, nc_vportmap, nc_networkmacromap, ingress_learning_acl, egress_learning_acl # Handling arguments args = get_args() configuration['debug'] = args.debug configuration['next_priority'] = args.first_priority configuration['log_file'] = None if args.logfile: configuration['log_file'] = args.logfile configuration['nuage_domain'] = args.nuage_domain configuration['nuage_enterprise'] = args.nuage_enterprise configuration['nuage_host'] = args.nuage_host configuration['nuage_port'] = args.nuage_port configuration['nuage_password'] = None if args.nuage_password: configuration['nuage_password'] = args.nuage_password configuration['nuage_username'] = args.nuage_username configuration['strictsource'] = args.strictsource configuration['nosslcheck'] = args.nosslcheck configuration['acl_type'] = args.acl_type configuration['verbose'] = args.verbose # Logging settings if configuration['debug']: log_level = logging.DEBUG elif configuration['verbose']: log_level = logging.INFO else: log_level = logging.WARNING logging.basicConfig(filename=configuration['log_file'], format='%(asctime)s %(levelname)s %(message)s', level=log_level) logger = logging.getLogger(__name__) # Getting user password for Nuage connection if configuration['nuage_password'] is None: logger.debug( 'No command line Nuage password received, requesting Nuage password from user' ) configuration['nuage_password'] = getpass.getpass( prompt='Enter password for Nuage host %s for user %s: ' % (configuration['nuage_host'], configuration['nuage_username'])) try: # Connecting to Nuage logger.info('Connecting to Nuage server %s:%s with username %s' % (configuration['nuage_host'], configuration['nuage_port'], configuration['nuage_username'])) nc = vsdk.NUVSDSession( username=configuration['nuage_username'], password=configuration['nuage_password'], enterprise=configuration['nuage_enterprise'], api_url="https://%s:%s" % (configuration['nuage_host'], configuration['nuage_port'])) nc.start() except Exception as e: logger.error( 'Could not connect to Nuage host %s with user %s and specified password' % (configuration['nuage_host'], configuration['nuage_username'])) logger.critical('Caught exception: %s' % str(e)) return 1 # Finding domain logger.debug('Finding domain %s' % configuration['nuage_domain']) nc_domain = nc.user.domains.get_first(filter="name == '%s'" % configuration['nuage_domain']) if nc_domain is None: logger.critical('Unable to find domain %s, quiting' % configuration['nuage_domain']) return 1 logger.info('Found domain %s' % nc_domain.name) # Getting enterprise logger.debug('Getting enterprise for domain %s' % nc_domain.name) nc_enterprise = vsdk.NUEnterprise(id=nc_domain.parent_id) nc_enterprise.fetch() if configuration['acl_type'] == 'SUBNET' or configuration[ 'acl_type'] == 'ZONE': # Mapping subnets logger.debug('Mapping subnets for domain %s' % nc_domain.name) for nc_subnet in nc_domain.subnets.get(): logger.debug( 'Found subnet with network %s/%s in domain %s' % (nc_subnet.address, nc_subnet.netmask, nc_domain.name)) nc_subnetmap[nc_subnet.id] = { 'id': nc_subnet.id, 'address': nc_subnet.address, 'netmask': nc_subnet.netmask, 'zone': nc_subnet.parent_id } if configuration['acl_type'] == 'POLICYGROUP': # Mapping policy groups logger.debug('Mapping policy groups for domain %s' % nc_domain.name) for nc_policygroup in nc_domain.policy_groups.get(): logger.debug('Found policy group %s in domain %s' % (nc_policygroup.name, nc_domain.name)) nc_policygroupmap[nc_policygroup.id] = { 'id': nc_policygroup.id, 'name': nc_policygroup.name } # Mapping vPorts logger.debug('Mapping vPorts for domain %s' % nc_domain.name) for nc_vport in nc_domain.vports.get(): logger.debug('Found vPort with IP %s and MAC %s in domain %s' % (nc_vport.vm_interfaces.get_first().ip_address, nc_vport.vm_interfaces.get_first().mac, nc_domain.name)) nc_vportmap[nc_vport.vm_interfaces.get_first().ip_address] = { 'id': nc_vport.id, 'mac': nc_vport.vm_interfaces.get_first().mac, 'subnet': nc_vport.parent_id, 'policygroups': [] } for nc_policygroup in nc_vport.policy_groups.get(): logger.debug( 'Found policy group %s for vPort with %s and MAC %s in domain %s' % (nc_policygroup.name, nc_vport.vm_interfaces.get_first().ip_address, nc_vport.vm_interfaces.get_first().mac, nc_domain.name)) nc_vportmap[nc_vport.vm_interfaces.get_first(). ip_address]['policygroups'].append({ 'id': nc_policygroup.id, 'name': nc_policygroup.name }) # Mapping Network Macros logger.debug('Mapping Network Macros for enterprise %s' % nc_enterprise.name) for nc_networkmacro in nc_enterprise.enterprise_networks.get(): logger.debug( 'Found Network Macro with IP %s and netmask %s for Enterprise %s' % (nc_networkmacro.address, nc_networkmacro.netmask, nc_enterprise.name)) nc_networkmacromap['%s-%s' % (nc_networkmacro.address, nc_networkmacro.netmask)] = { 'id': nc_networkmacro.id, 'address': nc_networkmacro.address, 'netmask': nc_networkmacro.netmask } # Checking if ACL logging rules are present ingress_learning_acl = nc_domain.ingress_acl_templates.get_first( filter="name == 'Ingress Learning ACLs'") egress_learning_acl = nc_domain.egress_acl_templates.get_first( filter="name == 'Egress Learning ACLs'") if ingress_learning_acl is None: logger.info('Creating Ingress Learning ACLs') ingress_learning_acl = vsdk.NUIngressACLTemplate( name='Ingress Learning ACLs', priority_type='NONE', priority=100, default_allow_non_ip=False, default_allow_ip=False, allow_l2_address_spoof=False, active=True) nc_domain.create_child(ingress_learning_acl, as_async=False) logger.debug('Creating Ingress ACL TCP rule') ingress_acl_entry_1 = vsdk.NUIngressACLEntryTemplate( action='FORWARD', description='Learning ACL for TCP traffic', ether_type='0x0800', flow_logging_enabled=True, location_type='ANY', network_type='ANY', priority=1000, protocol=6, reflexive=True, source_port='*', destination_port='*', dscp='*') ingress_learning_acl.create_child(ingress_acl_entry_1, as_async=False) logger.debug('Creating Ingress ACL UDP rule') ingress_acl_entry_2 = vsdk.NUIngressACLEntryTemplate( action='FORWARD', description='Learning ACL for UDP traffic', ether_type='0x0800', flow_logging_enabled=True, location_type='ANY', network_type='ANY', priority=1001, protocol=17, reflexive=True, source_port='*', destination_port='*', dscp='*') ingress_learning_acl.create_child(ingress_acl_entry_2, as_async=False) logger.debug('Creating Ingress ACL other rule') ingress_acl_entry_3 = vsdk.NUIngressACLEntryTemplate( action='FORWARD', description='Learning ACL for other traffic', ether_type='0x0800', flow_logging_enabled=True, location_type='ANY', network_type='ANY', priority=1002, protocol='ANY', source_port=None, destination_port=None, dscp='*') ingress_learning_acl.create_child(ingress_acl_entry_3, as_async=False) logger.info('Ingress ACL rules created') if egress_learning_acl is None: logger.info('Creating Egress Learning ACLs') egress_learning_acl = vsdk.NUEgressACLTemplate( name='Egress Learning ACLs', priority_type='NONE', priority=100, default_allow_non_ip=False, default_allow_ip=False, default_install_acl_implicit_rules=True, active=True) nc_domain.create_child(egress_learning_acl, as_async=False) logger.debug('Creating Egress ACL TCP rule') egress_acl_entry_1 = vsdk.NUEgressACLEntryTemplate( action='FORWARD', description='ACL for TCP traffic', ether_type='0x0800', flow_logging_enabled=True, location_type='ANY', network_type='ANY', priority=1000, protocol=6, reflexive=True, source_port='*', destination_port='*', dscp='*') egress_learning_acl.create_child(egress_acl_entry_1, as_async=False) logger.debug('Creating Egress ACL UDP rule') egress_acl_entry_2 = vsdk.NUEgressACLEntryTemplate( action='FORWARD', description='ACL for UDP traffic', ether_type='0x0800', flow_logging_enabled=True, location_type='ANY', network_type='ANY', priority=1001, protocol=17, reflexive=True, source_port='*', destination_port='*', dscp='*') egress_learning_acl.create_child(egress_acl_entry_2, as_async=False) logger.debug('Creating Egress ACL other rule') egress_acl_entry_3 = vsdk.NUEgressACLEntryTemplate( action='FORWARD', description='ACL for other traffic', ether_type='0x0800', flow_logging_enabled=True, location_type='ANY', network_type='ANY', priority=1002, protocol='ANY', source_port=None, destination_port=None, dscp='*') egress_learning_acl.create_child(egress_acl_entry_3, as_async=False) logger.info('Egress ACL rules created') logger.info('Starting capture server on port 514') capture_server = socketserver.TCPServer(('0.0.0.0', 514), ACLTCPHandler) try: # Activate the server; this will keep running until you # interrupt the program with Ctrl-C capture_server.serve_forever() except KeyboardInterrupt: logger.info('Received interrupt, finishing up') capture_server.shutdown() logger.info('All done!') return 1
def main(): """ Main function to handle statistics """ # Handling arguments args = get_args() debug = args.debug flush = args.flush 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__) # 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 nosslcheck: vc = SmartConnectNoSSL(host=vcenter_host, user=vcenter_username, pwd=vcenter_password, port=int(vcenter_port)) else: vc = SmartConnect(host=vcenter_host, user=vcenter_username, pwd=vcenter_password, port=int(vcenter_port)) except IOError as 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(r'\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(str( 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 isinstance(nc_subnet, 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 = not flush 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) if flush: vc_nicspec = vim.vm.device.VirtualDeviceSpec() vc_nicspec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit vc_nicspec.device = vc_vm_nic 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( 'Reconnecting NIC. 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( 'Successfully attached VM %s to Nuage subnet %s, in mode %s' % (vcenter_vm, nuage_vm_subnet, mode)) except vmodl.MethodFault as e: logger.critical('Caught vmodl fault: %s' % e.msg) return 1 except Exception as e: logger.critical('Caught exception: %s' % str(e)) return 0
nuage_host = args.nuage_host # Getting host port for Nuage connection if args.nuage_port is None: logger.debug( 'No command line Nuage host port received, default will be used.') nuage_port = 8443 else: nuage_port = args.nuage_port try: logger.info('Connecting to Nuage server %s:%s with username %s' % (nuage_host, nuage_port, nuage_username)) nc = vspk.NUVSDSession(username=nuage_username, password=nuage_password, enterprise=nuage_enterprise, api_url="https://{0}:{1}".format( nuage_host, nuage_port)) nc.start() nuage_user = nc.user except Exceptione as e: logger.error( 'Could not connect to Nuage host %s with user %s and specified password' % (nuage_host, nuage_username)) logger.critical('Caught exception: %s' % str(e)) exit() # Main logic for subnet in nuage_user.subnets.get(): if subnet.associated_shared_network_resource_id is not None: shared_net_obj = vspk.NUSharedNetworkResource( id=subnet.associated_shared_network_resource_id).fetch()[0]
def main(): """ Main function to handle vcenter vm os and the mapping to a policy group """ # Handling arguments args = get_args() clusters = [] if args.clusters: clusters = args.clusters debug = args.debug log_file = None if args.logfile: log_file = args.logfile mapping_file = args.mapping_file 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 remove_policygroups = args.remove_policygroups nosslcheck = args.nosslcheck verbose = args.verbose vcenter_host = args.vcenter_host vcenter_https_port = args.vcenter_https_port vcenter_password = None if args.vcenter_password: vcenter_password = args.vcenter_password vcenter_username = args.vcenter_username # 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__) # 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 {0:s} for user {1:s}: '. format(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 {0:s} for user {1:s}: '. format(vcenter_host, vcenter_username)) try: vc = None nc = None # Connecting to Nuage try: logger.info( 'Connecting to Nuage server {0:s}:{1:d} with username {2:s}'. format(nuage_host, nuage_port, nuage_username)) nc = vsdk.NUVSDSession(username=nuage_username, password=nuage_password, enterprise=nuage_enterprise, api_url="https://{0:s}:{1:d}".format( nuage_host, nuage_port)) nc.start() except IOError: pass if not nc or not nc.is_current_session(): logger.error( 'Could not connect to Nuage host {0:s} with user {1:s} and specified password' .format(nuage_host, nuage_username)) return 1 # Connecting to vCenter try: logger.info( 'Connecting to vCenter server {0:s}:{1:d} with username {2:s}'. format(vcenter_host, vcenter_https_port, vcenter_username)) if nosslcheck: vc = SmartConnectNoSSL(host=vcenter_host, user=vcenter_username, pwd=vcenter_password, port=int(vcenter_https_port)) else: vc = SmartConnect(host=vcenter_host, user=vcenter_username, pwd=vcenter_password, port=int(vcenter_https_port)) except IOError: pass if not vc: logger.error( 'Could not connect to vCenter host {0:s} with user {1:s} and specified password' .format(vcenter_host, vcenter_username)) return 1 logger.debug('Registering vCenter disconnect at exit') atexit.register(Disconnect, vc) logger.info('Connected to both Nuage & vCenter servers') except vmodl.MethodFault as e: logger.critical('Caught vmodl fault: {0:s}'.format(e.msg)) return 1 # CSV Handling if not os.path.isfile(mapping_file): logger.critical( 'Mapping file {0:s} does not exist, exiting'.format(mapping_file)) return 1 mapping_list = {} # CSV fields: # vCenter VM name regex, Policy group logger.debug('Parsing mapping file {0:s}'.format(mapping_file)) with open(mapping_file, 'rb') as maplist: mapping_list_raw = csv.reader(maplist, delimiter=',', quotechar='"') for row in mapping_list_raw: logger.debug('Found CSV row: {0:s}'.format(','.join(row))) mapping_list[row[0]] = row[1] # Getting clusters in the current vCenter logger.debug( 'Gathering all Clusters from the vCenter {0:s}'.format(vcenter_host)) content = vc.content obj_view = content.viewManager.CreateContainerView( content.rootFolder, [vim.ClusterComputeResource], True) vc_cl_list = obj_view.view obj_view.Destroy() for vc_cl in vc_cl_list: if vc_cl.name not in clusters: continue # Getting VMs in the current vCenter Cluster logger.debug('Gathering all VMs from the vCenter Cluster {0:s}'.format( vc_cl.name)) obj_view = content.viewManager.CreateContainerView( vc_cl, [vim.VirtualMachine], True) vc_vm_list = obj_view.view obj_view.Destroy() for vc_vm in vc_vm_list: # Verifying if VM matches a regex in the list logger.debug('Found VM {0:s}, checking'.format(vc_vm.name)) # If the VM is a template skip it if vc_vm.config.template: logger.debug('VM {0:s} is a template, skipping'.format( vc_vm.name)) continue # Getting VM info nc_vm_properties = {} vc_vm_nuage_enterprise = next((x for x in vc_vm.config.extraConfig if x.key == 'nuage.enterprise'), None) vc_vm_nuage_domain = next((x for x in vc_vm.config.extraConfig if x.key == 'nuage.nic0.domain'), None) vc_vm_nuage_l2domain = next((x for x in vc_vm.config.extraConfig if x.key == 'nuage.nic0.l2domain'), None) vc_vm_nuage_zone = next((x for x in vc_vm.config.extraConfig if x.key == 'nuage.nic0.zone'), None) vc_vm_nuage_network = next((x for x in vc_vm.config.extraConfig if x.key == 'nuage.nic0.network'), None) # Check if all the settings for an L3 domain are present if vc_vm_nuage_enterprise is None or vc_vm_nuage_domain is None or vc_vm_nuage_zone is None or vc_vm_nuage_network is None: # Check if it is an L2 domain if vc_vm_nuage_enterprise is None or vc_vm_nuage_l2domain is None: logger.info( 'VM {0:s} has no correct Nuage metadata set, assuming it is not a VM connected through Nuage and skipping it.' .format(vc_vm.name)) continue nc_vm_properties['name'] = vc_vm.name nc_vm_properties['os'] = vc_vm.config.guestFullName nc_vm_properties['nuage.enterprise'] = vc_vm_nuage_enterprise.value # If domain is not set, it is an l2 domain if vc_vm_nuage_domain is not None: nc_vm_properties['nuage.domain'] = vc_vm_nuage_domain.value nc_vm_properties['nuage.l2domain'] = None nc_vm_domain_name = vc_vm_nuage_domain.value else: nc_vm_properties['nuage.domain'] = None nc_vm_properties['nuage.l2domain'] = vc_vm_nuage_l2domain.value nc_vm_domain_name = vc_vm_nuage_l2domain.value if vc_vm_nuage_zone is not None: nc_vm_properties['nuage.zone'] = vc_vm_nuage_zone.value else: nc_vm_properties['nuage.zone'] = None if vc_vm_nuage_network is not None: nc_vm_properties['nuage.network'] = vc_vm_nuage_network.value else: nc_vm_properties['nuage.network'] = None logger.debug( 'VM {0:s} with OS {1:s} has following Nuage settings: Enterprise {2:s}, Domain {3:s}, Zone {4:s}, Subnet {5:s}' .format(nc_vm_properties['name'], nc_vm_properties['os'], nc_vm_properties['nuage.enterprise'], nc_vm_domain_name, nc_vm_properties['nuage.zone'], nc_vm_properties['nuage.network'])) # Getting VM MAC vc_vm_nic = next( (x for x in vc_vm.config.hardware.device if isinstance(x, vim.vm.device.VirtualEthernetCard)), None) if vc_vm_nic is None: logger.error( 'VM {0:s} has no valid network interfaces, skipping it'. format(nc_vm_properties['name'])) continue nc_vm_properties['mac'] = vc_vm_nic.macAddress logger.debug('VM {0:s} has MAC {1:s}'.format( nc_vm_properties['name'], nc_vm_properties['mac'])) # Getting Nuage vport for this VM nc_vm_properties['vm_interface'] = nc.user.vm_interfaces.get_first( filter="MAC == '{0:s}'".format(nc_vm_properties['mac'])) if nc_vm_properties['vm_interface'] is None: logger.error( 'VM {0:s} with MAC address {1:s} is not known in Nuage, skipping it' .format(nc_vm_properties['name'], nc_vm_properties['mac'])) continue # Getting Nuage vport for this VM nc_vm_properties['vport'] = vsdk.NUVPort( id=nc_vm_properties['vm_interface'].vport_id) try: nc_vm_properties['vport'].fetch() except BambouHTTPError: logger.error( 'VM {0:s} with MAC address {1:s} has a vm_interface but no vport in Nuage, this should not be possible... Skipping it' .format(nc_vm_properties['name'], nc_vm_properties['mac'])) continue logger.debug( 'Found vm_interface and vport for VM {0:s} with MAC address {1:s}' .format(nc_vm_properties['name'], nc_vm_properties['mac'])) # Checking regex's on VMs nc_vm_pgs = [] for regex in list(mapping_list.keys()): logger.debug( 'Checking regex "{0:s}" on VM {1:s} with OS {2:s}'.format( regex, nc_vm_properties['name'], nc_vm_properties['os'])) pattern = re.compile(regex) if pattern.match(nc_vm_properties['os']): logger.debug( 'Found match: regex "{0:s}" and VM OS "{1:s}", adding to the task list to hand over to Nuage.' .format(regex, nc_vm_properties['os'])) nc_vm_pgs.append(mapping_list[regex]) if len(nc_vm_pgs) > 0: logger.debug( 'Handing task over to Nuage part to set {0:d} Policy Groups on VM {1:s}' .format(len(nc_vm_pgs), nc_vm_properties['name'])) update_nuage_policy_group( logger=logger, nc=nc, nc_vm_properties=nc_vm_properties, nc_vm_pgs=nc_vm_pgs, remove_policygroups=remove_policygroups) logger.info('All done!') return 0
def main(): """ Main function to handle vcenter vm names and the mapping to a policy group """ # Handling arguments args = get_args() debug = args.debug extended = args.extended json_output = args.json_output log_file = None if args.logfile: log_file = args.logfile 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 time_difference = args.time_difference verbose = args.verbose # 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__) # Validating time_difference input time_check = re.compile('^([0-9]+)([m|h|d]?)$') time_matches = time_check.match(time_difference) if time_matches is None: logger.critical('The time indication %s is an invalid value, exiting' % time_difference) return 1 time_diff = int(float(time_matches.group(1))) if time_matches.group(2) == 'm': logger.debug('Found m in the time difference, multiplying integer by 60') time_diff *= 60 elif time_matches.group(2) == 'h': logger.debug('Found h in the time difference, multiplying integer by 3600') time_diff *= 3600 elif time_matches.group(2) == 'd': logger.debug('Found d in the time difference, multiplying integer by 86400') time_diff *= 86400 logger.debug('Time difference set to %s seconds' % time_diff) # 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)) try: # 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() except Exception as e: logger.error('Could not connect to Nuage host %s with user %s and specified password' % (nuage_host, nuage_username)) logger.critical('Caught exception: %s' % str(e)) return 1 if json_output: logger.debug('JSON output enabled, not setting up an output table') json_object = [] elif extended: logger.debug('Setting up extended output table') pt = PrettyTable(['Enterprise', 'Timestamp', 'Date/Time', 'Type', 'Entity', 'Entity parent', 'Extended info']) else: logger.debug('Setting up basic output table') pt = PrettyTable(['Enterprise', 'Timestamp', 'Date/Time', 'Type', 'Entity', 'Entity parent']) unix_check_time = time.time() - time_diff logger.debug('Gathering all events from after UNIX timestamp %s' % unix_check_time) for ent in nc.user.enterprises.get(): logger.debug('Gathering events for enterprise %s' % ent.name) for event in ent.event_logs.get(filter="eventReceivedTime >= '%s'" % int(unix_check_time * 1000)): logger.debug('Found event of type %s with timestamp %s' % (event.type, event.event_received_time)) clean_time = datetime.datetime.fromtimestamp(int(old_div(event.event_received_time, 1000))).strftime('%Y-%m-%d %H:%M:%S') if json_output: json_dict = { 'Enterprise': ent.name, 'Timestamp': event.event_received_time, 'Date/Time': clean_time, 'Type': event.type, 'Entity': event.entity_type, 'Entity parent': event.entity_parent_type } if extended: json_dict['Extended info'] = event.entities json_object.append(json_dict) elif extended: pt.add_row([ent.name, event.event_received_time, clean_time, event.type, event.entity_type, event.entity_parent_type, json.dumps(event.entities)]) else: pt.add_row([ent.name, event.event_received_time, clean_time, event.type, event.entity_type, event.entity_parent_type]) logger.debug('Printing output') if json_output: print(json.dumps(json_object, sort_keys=True, indent=4)) else: print(pt.get_string(sortby='Timestamp')) return 0
from vspk import v6 as vsdk if __name__ == '__main__': # Connection with a certificate cert = ("/path/to/csproot.pem", "/path/to/csproot-Key.pem") session = vsdk.NUVSDSession(username='******', enterprise='csp', api_url='https://localhost:7443', certificate=cert) session.start() # Reset the session to start a new one session.reset() # Connection with a user/password session = vsdk.NUVSDSession(username="******", password="******", enterprise="csp", api_url="https://localhost:8443") session.start()
def main(): """ Main function to handle vcenter vm names and the mapping to a policy group """ # Handling arguments args = get_args() debug = args.debug json_output = args.json_output log_file = None if args.logfile: log_file = args.logfile 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 # 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__) # 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)) try: # 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() except Exception as e: logger.error('Could not connect to Nuage host %s with user %s and specified password' % (nuage_host, nuage_username)) logger.critical('Caught exception: %s' % str(e)) return 1 if json_output: logger.debug('Setting up json output') json_object = [] else: logger.debug('Setting up basic output table') pt = PrettyTable(['Enterprise', 'Domain', 'VM Name', 'VM IP', 'VM MAC', 'FIP']) logger.debug('Getting FIPs for the logged in user.') for nc_fip in nc.user.floating_ips.get(): logger.debug('Found FIP with IP %s' % nc_fip.address) nc_vport = nc_fip.vports.get()[0] nc_interface = nc_vport.vm_interfaces.get()[0] nc_vm = nc_vport.vms.get()[0] if json_output: json_dict = { 'Enterprise': nc_vm.enterprise_name, 'Domain': nc_interface.domain_name, 'VM Name': nc_vm.name, 'VM IP': nc_interface.ip_address, 'VM MAC': nc_interface.mac, 'FIP': nc_fip.address } json_object.append(json_dict) else: logger.debug('Add row: %s, %s, %s, %s, %s, %s' % (nc_vm.enterprise_name, nc_interface.domain_name, nc_vm.name, nc_interface.ip_address, nc_interface.mac, nc_fip.address)) pt.add_row([nc_vm.enterprise_name, nc_interface.domain_name, nc_vm.name, nc_interface.ip_address, nc_interface.mac, nc_fip.address]) if json_output: print(json.dumps(json_object, sort_keys=True, indent=4)) else: print(pt) return 0
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 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 ips = [] if args.ips: ips = args.ips macs = args.macs subnets = args.subnets uuid = args.uuid # 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__) # Sanity checks if len(macs) > 0 and len(macs) != len(subnets): logger.critical('The amount of macs is not equal to the amount of subnets, which is an invalid configuration.') return 1 if len(ips) > 0 and len(macs) != len(ips): logger.critical('Some IPs are specified, but not the same amount as macs and subnets, which is an invalid configuration.') return 1 # 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 {0:s} for user {1:s}: '.format(nuage_host, nuage_username)) try: # Connecting to Nuage logger.info('Connecting to Nuage server {0:s}:{1:d} with username {2:s}'.format(nuage_host, nuage_port, nuage_username)) nc = vsdk.NUVSDSession(username=nuage_username, password=nuage_password, enterprise=nuage_enterprise, api_url="https://{0:s}:{1:d}".format(nuage_host, nuage_port)) nc.start() except Exception as e: logger.error('Could not connect to Nuage host {0:s} with user {1:s} and specified password'.format(nuage_host, nuage_username)) logger.critical('Caught exception: {0:s}'.format(str(e))) return 1 logger.debug('Trying to fetch VM with ID {0:s}'.format(uuid)) vm = vsdk.NUVM(id=uuid) vm.fetch() for mac in macs: index = macs.index(mac) subnet_id = subnets[index] subnet_type = None logger.info('Handling mac address {0:s} connection to subnet or L2 domain {1:s}'.format(mac, subnet_id)) logger.debug('Trying to fetch subnet for ID {0:s}'.format(subnet_id)) try: subnet = vsdk.NUSubnet(id=subnet_id) subnet.fetch() subnet_type = 'SUBNET' except: logger.debug('Subnet with ID {0:s} does not exist, looking for a L2 domain'.format(subnet_id)) try: subnet = vsdk.NUL2Domain(id=subnet_id) subnet.fetch() subnet_type = 'L2DOMAIN' except: logger.error('Subnet with ID {0:s} can not be found as an subnet in an L3 domain or as an L2 domain, skipping mac {1:s} and subnet {2:s} and continuing to the next pair'.format(subnet_id, mac, subnet_id)) continue vm_interface = vsdk.NUVMInterface() if len(ips) > 0: vm_interface.ip_address = ips[index] vm_interface.mac = mac vm_interface.name = 'if-{0:s}'.format(mac).replace(':','-') vm_interface.attached_network_id = subnet_id vm_interface.attached_network_type = subnet_type logger.debug('Creating interface {0:s} on VM {1:s}'.format(vm_interface.name, vm.name)) try: vm.create_child(vm_interface) except Exception as e: logger.error('Failed to create interface {0:s} on VM {1:s}: {2:s}'.format(vm_interface.name, vm.name, str(e))) logger.info('Successfully added interfaces to VM {0:s}'.format(vm.name)) return 0
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 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 vmid = args.vmid # 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__) # 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)) try: # 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() except Exception as e: logger.error('Could not connect to Nuage host %s with user %s and specified password' % (nuage_host, nuage_username)) logger.critical('Caught exception: %s' % str(e)) return 1 # Creating VM logger.info('Deleting VM %s' % vmid) vm = vsdk.NUVM(id=vmid) try: vm.fetch() logger.debug('Getting vPorts') vport_ids = [] for interface in vm.vm_interfaces.get(): vport_ids.append(interface.vport_id) logger.debug('Trying to delete VM %s.' % vmid) vm.delete() logger.debug('Trying to delete vports.') for vport in vport_ids: vport = vsdk.NUVPort(id=vport) vport.delete() except Exception as e: logger.critical('VM %s can not be deleted because of error %s' % (vmid, str(e))) return 1 logger.info('Deleted VM %s' % vmid) return 0
timeout_start = time.time() while time.time() < timeout_start + timeout: job.fetch() if job.status == 'SUCCESS': print('SUCCESS :: Re-keying Job succeeded!') return True if job.status == 'FAILED': return False time.sleep(1) print('ERROR :: Job {} failed to return its status in {}sec interval'.format( job.command, timeout)) nuage_session = vspk.NUVSDSession( username=n_username, password=n_password, enterprise=n_org, api_url=api_url) me = nuage_session.start().user # get parent for the re-key job object org = me.enterprises.get_first(filter='name == "{}"'.format(org_name)) # create job object job = vspk.NUJob(command='FORCE_KEYSERVER_UPDATE') print('Starting {} job for the {} Organization'.format( 'FORCE_KEYSERVER_UPDATE', org.name))
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 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 vmid = args.vmid uuid = args.uuid # 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__) # 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)) try: # 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() except Exception as e: logger.error('Could not connect to Nuage host %s with user %s and specified password' % (nuage_host, nuage_username)) logger.critical('Caught exception: %s' % str(e)) return 1 # Updating VM UUID logger.info('Updating VM %s UUID to %s' % (vmid, uuid)) vm = vsdk.NUVM(id=vmid) try: vm.fetch() logger.debug('VM ID %s - OLD UUID %s - NEW UUID %s' % (vmid, vm.uuid, uuid)) vm.uuid = uuid vm.resync_info = None vm.save() except Exception as e: logger.critical('VM %s can not be updated because of error %s' % (vmid, str(e))) return 1 logger.info('Updated VM %s' % vmid) return 0
for cur_rule in cur_acl.ingress_acl_entry_templates.get(): print(' |- Rule: %s' % cur_rule.description) for cur_acl in cur_domain.egress_acl_templates.get(): print(' |- Egress ACL: %s' % cur_acl.name) for cur_rule in cur_acl.egress_acl_entry_templates.get(): print(' |- Rule: %s' % cur_rule.description) print( '--------------------------------------------------------------------------------' ) session_1 = vsdk.NUVSDSession(username='******', enterprise='csp', certificate=('nuage/vsd01.nuage.intern.pem', 'nuage/vsd01.nuage.intern-Key.pem'), api_url='https://vsd01.nuage.intern:7443') session_1.start() session_2 = vsdk.NUVSDSession( username='******', enterprise='csp', certificate=('nuage/vsd02.nuage.intern.pem', '/Users/pdellaer/nuage/vsd02.nuage.intern-Key.pem'), api_url='https://vsd02.nuage.intern:7443') session_2.start() session_3 = vsdk.NUVSDSession(username='******', password='******', enterprise='csp',
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 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 external = args.external ips = [] if args.ips: ips = args.ips macs = args.macs name = args.name subnets = args.subnets uuid = args.uuid # 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__) # Sanity checks if len(macs) > 0 and len(macs) != len(subnets): logger.critical( 'The amount of macs is not equal to the amount of subnets, which is an invalid configuration.' ) return 1 if len(ips) > 0 and len(macs) != len(ips): logger.critical( 'Some IPs are specified, but not the same amount as macs and subnets, which is an invalid configuration.' ) return 1 # 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)) try: # 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() except Exception as e: logger.error( 'Could not connect to Nuage host %s with user %s and specified password' % (nuage_host, nuage_username)) logger.critical('Caught exception: %s' % str(e)) return 1 # Handling each mac/subnet combination and creating the necessary vPorts and VM Interfaces vports = [] vm_interfaces = [] for mac in macs: index = macs.index(mac) subnet_id = subnets[index] logger.info( 'Handling mac address %s connection to subnet or L2 domain %s' % (mac, subnet_id)) logger.debug('Trying to fetch subnet for ID %s' % subnet_id) try: subnet = vsdk.NUSubnet(id=subnet_id) subnet.fetch() except: logger.debug( 'Subnet with ID %s does not exist, looking for a L2 domain' % subnet_id) try: subnet = vsdk.NUL2Domain(id=subnet_id) subnet.fetch() except: logger.error( 'Subnet with ID %s can not be found as an subnet in an L3 domain or as an L2 domain, skipping mac %s and subnet %s and continuing to the next pair' % (subnet_id, mac, subnet_id)) continue # Creating vPort in subnet logger.debug('Creating vPort %s-vPort-%s in subnet %s (%s)' % (name, index, subnet.name, subnet_id)) vport = vsdk.NUVPort(name='%s-vPort-%s' % (name, index), address_spoofing='INHERITED', type='VM', description='Automatically created, do not edit.') if external: vport.external_id = '%s-vPort-%s' % (name, index) subnet.create_child(vport) vports.append(vport) # Creating VMInterface logger.debug( 'Creating VMInterface object %s-vm-interface-%s for mac %s with vPort ID %s' % (name, index, mac, vport.id)) vm_interface = vsdk.NUVMInterface(name='%s-vm-interface-%s' % (name, index), vport_id=vport.id, mac=mac) if external: vm_interface.external_id = '%s-vm-interface-%s' % (name, index) if len(ips) > 0: vm_interface.ip_address = ips[index] vm_interfaces.append(vm_interface) # Creating VM logger.info('Creating VM %s with UUID %s' % (name, uuid)) vm = vsdk.NUVM(name=name, uuid=uuid, interfaces=vm_interfaces) if external: vm.external_id = uuid try: logger.debug('Trying to save VM %s.' % name) nc.user.create_child(vm) except Exception as e: logger.critical('VM %s can not be created because of error %s' % (name, str(e))) logger.debug('Cleaning up the vPorts') for vport in vports: logger.debug('Deleting vPort %s' % vport.name) vport.delete() return 1 logger.info( 'Created all necessary entities in the appropriate subnets or L2 domains for VM %s' % name) return 0
def main(): """ Main function to handle statistics """ # Handling arguments args = get_args() debug = args.debug json_output = args.json_output log_file = None if args.logfile: log_file = args.logfile 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 verbose = args.verbose # 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__) # 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 {0:s} for user {1:s}: '.format(nuage_host, nuage_username)) try: # 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://{0:s}:{1:d}".format(nuage_host, nuage_port)) nc.start() except Exception as e: logger.error('Could not connect to Nuage host {0:s} with user {1:s} and specified password'.format( nuage_host, nuage_username)) logger.critical('Caught exception: {0:s}'.format(str(e))) return 1 if json_output: logger.debug('Setting up json output') json_object = [] else: logger.debug('Setting up basic output table') pt = PrettyTable(['Enterprise', 'Domain', '# vPorts']) logger.debug('Fetching enterprises with flow collection enabled') for ent in nc.user.enterprises.get(filter='flowCollectionEnabled == "ENABLED"'): logger.debug('Handling enterprise: {0:s}'.format(ent.name)) for dom in ent.domains.get(filter='flowCollectionEnabled == "INHERITED" OR flowCollectionEnabled == "ENABLED"'): logger.debug('Handling domain: {0:s}'.format(dom.name)) _, _, vport_count = dom.vports.count() if json_output: json_dict = { 'Enterprise': ent.name, 'Domain': dom.name, '# vPorts': vport_count } json_object.append(json_dict) else: logger.debug('Add row: {0:s}, {1:s}, {2:d}'.format( ent.name, dom.name, vport_count)) pt.add_row([ent.name, dom.name, vport_count]) if json_output: print(json.dumps(json_object, sort_keys=True, indent=4)) else: print(pt) return 0
def main(): """ Backup the vCenter Integration Node configuration """ # Handling arguments args = get_args() debug = args.debug log_file = None if args.logfile: log_file = args.logfile 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 output_folder = args.output_folder # nosslcheck = args.nosslcheck verbose = args.verbose # 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__) # Checking if folder is writeable if not os.access(output_folder, os.W_OK): logger.critical( 'Folder {0:s} is not writable, exiting.'.format(output_folder)) return 1 # 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 {0:s} for user {1:s}: '. format(nuage_host, nuage_username)) nc = None # Connecting to Nuage try: logger.info( 'Connecting to Nuage server {0:s}:{1:d} with username {2:s}'. format(nuage_host, nuage_port, nuage_username)) nc = vsdk.NUVSDSession(username=nuage_username, password=nuage_password, enterprise=nuage_enterprise, api_url="https://{0:s}:{1:d}".format( nuage_host, nuage_port)) nc.start() except IOError: pass if not nc or not nc.is_current_session(): logger.error( 'Could not connect to Nuage host {0:s} with user {1:s} and specified password' .format(nuage_host, nuage_username)) return 1 logger.info('Connected to Nuage') # Run through each vCenter for nvc in nc.user.vcenters.get(): logger.debug('Running for vCenter {0:s}'.format(nvc.name)) hosts = [] for ndc in nvc.vcenter_data_centers.get(): logger.debug('Running for DC {0:s}'.format(ndc.name)) for ncl in ndc.vcenter_clusters.get(): logger.debug('Running for cluster {0:s}'.format(ncl.name)) for host in ncl.vcenter_hypervisors.get(): logger.debug('Handling host {0:s}'.format(host.name)) host = [ host.hypervisor_ip, host.name, host.hypervisor_user, host.hypervisor_password, host.mgmt_network_portgroup, host.data_network_portgroup, host.vm_network_portgroup, host.multicast_source_portgroup, host.allow_mgmt_dhcp, host.mgmt_ip_address, host.mgmt_netmask, host.mgmt_gateway, host.mgmt_dns1, host.mgmt_dns2, host.separate_data_network, host.allow_data_dhcp, host.data_ip_address, host.data_netmask, host.data_gateway, host.data_dns1, host.data_dns2, host.mtu, host.v_require_nuage_metadata, host.generic_split_activation, host.multi_vmssupport, host.dhcp_relay_server, host.flow_eviction_threshold, host.datapath_sync_timeout, host.network_uplink_interface, host.network_uplink_interface_ip, host.network_uplink_interface_netmask, host.network_uplink_interface_gateway, host.customized_script_url, host.personality, host.site_id, host.nfs_log_server, host.nfs_mount_path, host.primary_nuage_controller, host.secondary_nuage_controller, host.ntp_server1, host.ntp_server2, host.static_route, host.static_route_netmask, host.static_route_gateway, host.multicast_send_interface, host.multicast_send_interface_ip, host.multicast_send_interface_netmask, host.multicast_receive_interface_ip, host.multicast_receive_interface_netmask, '', '' ] hosts.append(host) logger.debug('Writing CSV for vCenter {0:s}'.format(nvc.name)) with open('{0:s}/{1:s}.csv'.format(output_folder, nvc.name), 'w') as hostlist: writer = csv.writer(hostlist, delimiter=',', quotechar='"', quoting=csv.QUOTE_ALL) writer.writerows(hosts) logger.info('Completed all tasks.') return 0
def main(): """ Main function to gather the information on the VM applied policies """ global configuration, logger, output_parser # Handling arguments args = get_args() configuration = {} configuration['debug'] = args.debug configuration['json_output'] = args.json_output configuration['log_file'] = None if args.logfile: configuration['log_file'] = args.logfile configuration['nuage_enterprise'] = args.nuage_enterprise configuration['nuage_host'] = args.nuage_host configuration['nuage_port'] = args.nuage_port configuration['nuage_password'] = None if args.nuage_password: configuration['nuage_password'] = args.nuage_password configuration['nuage_username'] = args.nuage_username configuration['verbose'] = args.verbose # Logging settings if configuration['debug']: log_level = logging.DEBUG elif configuration['verbose']: log_level = logging.INFO else: log_level = logging.WARNING logging.basicConfig(filename=configuration['log_file'], format='%(asctime)s %(levelname)s %(message)s', level=log_level) logger = logging.getLogger(__name__) # Getting user password for Nuage connection if configuration['nuage_password'] is None: logger.debug('No command line Nuage password received, requesting Nuage password from user') configuration['nuage_password'] = getpass.getpass(prompt='Enter password for Nuage host %s for user %s: ' % (configuration['nuage_host'], configuration['nuage_username'])) try: # Connecting to Nuage logger.debug('Connecting to Nuage server %s:%s with username %s' % (configuration['nuage_host'], configuration['nuage_port'], configuration['nuage_username'])) nc = vsdk.NUVSDSession(username=configuration['nuage_username'], password=configuration['nuage_password'], enterprise=configuration['nuage_enterprise'], api_url="https://%s:%s" % (configuration['nuage_host'], configuration['nuage_port'])) nc.start() except Exception as e: logger.error('Could not connect to Nuage host %s with user %s and specified password' % (configuration['nuage_host'], configuration['nuage_username'])) logger.critical('Caught exception: %s' % str(e)) return 1 # Setting output correctly output_fields = [ 'VM Name', 'Interface MAC', 'Enterprise', 'Domain', 'Domain type', 'ACL type', 'Ether type', 'Protocol', 'Source type', 'Source name', 'Destination type', 'Destination name', 'Source port', 'Destination port', 'DSCP', 'Stateful', 'Action' ] # Starting output if configuration['json_output']: logger.debug('JSON output enabled, not setting up an output table') output_parser = [] else: logger.debug('Setting up output table') output_parser = PrettyTable(output_fields) # Gathering Enterprises for enterprise in nc.user.enterprises.get(): logger.debug('Handling enterprise {0:s}'.format(enterprise.name)) # Handling L2 domains for l2_domain in enterprise.l2_domains.get(): logger.debug('Checking if L2 domain {0:s} is connected to a Shared Network'.format(l2_domain.name)) if l2_domain.associated_shared_network_resource_id: logger.info('L2 domain {0:s} is linked to a Shared Network'.format(l2_domain.name)) for vm_interface in l2_domain.vm_interfaces.get(): logger.debug('Handling VM interface with MAC {0:s}'.format(vm_interface.mac)) handle_vm_interface(vm_interface=vm_interface, enterprise=enterprise, domain=l2_domain, domain_type='L2', nc=nc) # Handling L3 domains for domain in enterprise.domains.get(): logger.debug('Checking if domain {0:s} has a subnet connected to a Shared Network'.format(domain.name)) for subnet in domain.subnets.get(): logger.debug('Checking if subnet {0:s} is connected to a Shared Network'.format(subnet.name)) if subnet.associated_shared_network_resource_id: logger.info('Subnet {0:s} is linked to a Shared Network'.format(subnet.name)) for vm_interface in subnet.vm_interfaces.get(): logger.debug('Handling VM interface with MAC {0:s}'.format(vm_interface.mac)) handle_vm_interface(vm_interface=vm_interface, enterprise=enterprise, domain=domain, domain_type='L3', nc=nc) logger.debug('Printing output') if configuration['json_output']: print(json.dumps(output_parser, sort_keys=True, indent=4)) else: print(output_parser.get_string()) return 0
def main(): """ Main function to gather the information on the VM applied policies """ global configuration, logger, output_parser # Handling arguments args = get_args() configuration = {} configuration['debug'] = args.debug configuration['json_output'] = args.json_output configuration['log_file'] = None if args.logfile: configuration['log_file'] = args.logfile configuration['nuage_enterprise'] = args.nuage_enterprise configuration['nuage_host'] = args.nuage_host configuration['nuage_port'] = args.nuage_port configuration['nuage_password'] = None if args.nuage_password: configuration['nuage_password'] = args.nuage_password configuration['nuage_username'] = args.nuage_username # configuration['nosslcheck'] = args.nosslcheck configuration['verbose'] = args.verbose configuration['vm_names'] = [] if args.vm_names: configuration['vm_names'] = args.vm_names # Logging settings if configuration['debug']: log_level = logging.DEBUG elif configuration['verbose']: log_level = logging.INFO else: log_level = logging.WARNING logging.basicConfig(filename=configuration['log_file'], format='%(asctime)s %(levelname)s %(message)s', level=log_level) logger = logging.getLogger(__name__) # Getting user password for Nuage connection if configuration['nuage_password'] is None: logger.debug('No command line Nuage password received, requesting Nuage password from user') configuration['nuage_password'] = getpass.getpass(prompt='Enter password for Nuage host %s for user %s: ' % (configuration['nuage_host'], configuration['nuage_username'])) try: # Connecting to Nuage logger.debug('Connecting to Nuage server %s:%s with username %s' % (configuration['nuage_host'], configuration['nuage_port'], configuration['nuage_username'])) nc = vsdk.NUVSDSession(username=configuration['nuage_username'], password=configuration['nuage_password'], enterprise=configuration['nuage_enterprise'], api_url="https://%s:%s" % (configuration['nuage_host'], configuration['nuage_port'])) nc.start() except Exception as e: logger.error('Could not connect to Nuage host %s with user %s and specified password' % (configuration['nuage_host'], configuration['nuage_username'])) logger.critical('Caught exception: %s' % str(e)) return 1 # Setting output correctly output_fields = [ 'VM Name', 'Interface MAC', 'ACL type', 'Ether type', 'Protocol', 'Source type', 'Source name', 'Destination type', 'Destination name', 'Source port', 'Destination port', 'DSCP', 'Stateful', 'Action' ] # Gathering VMs vms = [] if configuration['vm_names']: for vm_name in configuration['vm_names']: logger.debug('Getting VMs matching the name %s' % vm_name) entities = nc.user.vms.get(filter='name == "%s"' % vm_name) vms.extend(entities) else: logger.debug('Getting all VMs') vms = nc.user.vms.get() # Gathering VM Interfaces vm_interfaces = [] logger.debug('Getting all VM interfaces for the selected VMs') for vm in vms: vm_interfaces.extend(vm.vm_interfaces.get()) # Verifying if there are enities if len(vm_interfaces) == 0: logger.critical('No matching vms found') return 1 # Starting output if configuration['json_output']: logger.debug('JSON output enabled, not setting up an output table') output_parser = [] else: logger.debug('Setting up output table') output_parser = PrettyTable(output_fields) # Gathering ACL rules and handling them for vm_interface in vm_interfaces: logger.debug('Gathering VM interface policy decisions') policy_decisions = vm_interface.policy_decisions.get_first() ingress_acl_entries = policy_decisions.ingress_acls[0]['entries'] egress_acl_entries = policy_decisions.egress_acls[0]['entries'] forward_acl_entries = policy_decisions.ingress_adv_fwd[0]['entries'] logger.debug('Found %s ingress ACLs and %s egress ACLs' % (len(ingress_acl_entries), len(egress_acl_entries))) logger.debug('Handling Ingress ACL entries') for entry in ingress_acl_entries: acl_rule = None logger.debug('Using minimal information from the policy decision entry itself') output = { 'VM Name': vm_interface.parent.name, 'Interface MAC': vm_interface.mac, 'ACL type': 'Ingress', 'Ether type': entry['etherType'], 'Protocol': entry['protocol'], 'Source type': 'VM', 'Source name': vm_interface.parent.name, 'Destination type': entry['destinationType'], 'Destination name': entry['destinationValue'], 'Source port': entry['sourcePort'], 'Destination port': entry['destinationPort'], 'DSCP': entry['DSCP'], 'Stateful': '', 'Action': entry['actionDetails']['actionType'] } if entry['aclTemplateEntryId']: logger.debug('Finding the actual Ingress ACL Template Entry to use its data') # We are using this approach with the Stats ID as the aclTemplateEntryId points to the stats ID of an Ingress/Egress ACL Entry Template in the current version (bug report generated) acl_rule = nc.user.ingress_acl_entry_templates.get_first(filter='statsID == "%s"' % entry['aclTemplateEntryId']) if acl_rule: logger.debug('Found a matching Ingress ACL Template Entry: %s' % acl_rule.description) output['Ether type'] = acl_rule.ether_type output['Protocol'] = acl_rule.protocol output['Source type'] = acl_rule.location_type if acl_rule.location_type and nc.user.fetcher_for_rest_name(acl_rule.location_type.lower()) is not None: output['Source name'] = nc.user.fetcher_for_rest_name(acl_rule.location_type.lower()).get_first(filter='ID == "%s"' % acl_rule.location_id).name output['Destination type'] = acl_rule.network_type if acl_rule.network_type and nc.user.fetcher_for_rest_name(acl_rule.network_type.lower()) is not None: output['Destination name'] = nc.user.fetcher_for_rest_name(acl_rule.network_type.lower()).get_first(filter='ID == "%s"' % acl_rule.network_id).name output['Source port'] = acl_rule.source_port output['Destination port'] = acl_rule.destination_port output['DSCP'] = acl_rule.dscp output['Stateful'] = acl_rule.stateful output['Action'] = acl_rule.action handle_output(output=output) logger.debug('Handling Egress ACL entries') for entry in egress_acl_entries: acl_rule = None logger.debug('Using minimal information from the policy decision entry itself') output = { 'VM Name': vm_interface.parent.name, 'Interface MAC': vm_interface.mac, 'ACL type': 'Egress', 'Ether type': entry['etherType'], 'Protocol': entry['protocol'], 'Source type': 'VM', 'Source name': vm_interface.parent.name, 'Destination type': entry['destinationType'], 'Destination name': entry['destinationValue'], 'Source port': entry['sourcePort'], 'Destination port': entry['destinationPort'], 'DSCP': entry['DSCP'], 'Stateful': '', 'Action': entry['actionDetails']['actionType'] } if entry['aclTemplateEntryId']: logger.debug('Finding the actual Egress ACL Template Entry to use its data') # We are using this approach with the Stats ID as the aclTemplateEntryId points to the stats ID of an Ingress/Egress ACL Entry Template in the current version (bug report generated) acl_rule = nc.user.egress_acl_entry_templates.get_first(filter='statsID == "%s"' % entry['aclTemplateEntryId']) if acl_rule: logger.debug('Found a matching Egress ACL Template Entry: %s' % acl_rule.description) output['Ether type'] = acl_rule.ether_type output['Protocol'] = acl_rule.protocol output['Source type'] = acl_rule.location_type if acl_rule.location_type and nc.user.fetcher_for_rest_name(acl_rule.location_type.lower()) is not None: output['Source name'] = nc.user.fetcher_for_rest_name(acl_rule.location_type.lower()).get_first(filter='ID == "%s"' % acl_rule.location_id).name output['Destination type'] = acl_rule.network_type if acl_rule.network_type and nc.user.fetcher_for_rest_name(acl_rule.network_type.lower()) is not None: output['Destination name'] = nc.user.fetcher_for_rest_name(acl_rule.network_type.lower()).get_first(filter='ID == "%s"' % acl_rule.network_id).name output['Source port'] = acl_rule.source_port output['Destination port'] = acl_rule.destination_port output['DSCP'] = acl_rule.dscp output['Stateful'] = acl_rule.stateful output['Action'] = acl_rule.action handle_output(output=output) logger.debug('Handling Redirect policies entries') for entry in forward_acl_entries: acl_rule = None logger.debug('Using minimal information from the policy decision entry itself') output = { 'VM Name': vm_interface.parent.name, 'Interface MAC': vm_interface.mac, 'ACL type': 'Forward', 'Ether type': entry['etherType'], 'Protocol': entry['protocol'], 'Source type': 'VM', 'Source name': vm_interface.parent.name, 'Destination type': entry['destinationType'], 'Destination name': entry['destinationValue'], 'Source port': entry['sourcePort'], 'Destination port': entry['destinationPort'], 'DSCP': entry['DSCP'], 'Stateful': '', 'Action': entry['actionDetails']['actionType'] } if entry['ingressAdvFwdTemplateEntryId']: logger.debug('Finding the actual Ingress Advanced ACL Template Entry to use its data') # We are using this approach with the Stats ID as the ingressAdvFwdTemplateEntryId points to the stats ID of an Ingress/Egress ACL Entry Template in the current version (bug report generated) acl_rule = nc.user.ingress_adv_fwd_entry_templates.get_first(filter='statsID == "%s"' % entry['ingressAdvFwdTemplateEntryId']) if acl_rule: logger.debug('Found a matching Ingress Advanced ACL Template Entry: %s' % acl_rule.description) output['Ether type'] = acl_rule.ether_type output['Protocol'] = acl_rule.protocol output['Source type'] = acl_rule.location_type if acl_rule.location_type and nc.user.fetcher_for_rest_name(acl_rule.location_type.lower()) is not None: output['Source name'] = nc.user.fetcher_for_rest_name(acl_rule.location_type.lower()).get_first(filter='ID == "%s"' % acl_rule.location_id).name output['Destination type'] = acl_rule.network_type if acl_rule.network_type and nc.user.fetcher_for_rest_name(acl_rule.network_type.lower()) is not None: output['Destination name'] = nc.user.fetcher_for_rest_name(acl_rule.network_type.lower()).get_first(filter='ID == "%s"' % acl_rule.network_id).name output['Source port'] = acl_rule.source_port output['Destination port'] = acl_rule.destination_port output['DSCP'] = acl_rule.dscp output['Action'] = acl_rule.action handle_output(output=output) logger.debug('Printing output') if configuration['json_output']: print(json.dumps(output_parser, sort_keys=True, indent=4)) else: print(output_parser.get_string()) return 0
from __future__ import print_function import logging from vspk import v6 as vsdk from vspk.utils import set_log_level set_log_level(logging.ERROR) session = vsdk.NUVSDSession(username='******', password='******', enterprise='csp', api_url='https://localhost:8443') session.start() csproot = session.user # Count will make a request to the backend to retrieve the number of enterprises (_, _, nb_enterprises) = csproot.enterprises.count() print('Number of enterprises to retrieve = %s' % nb_enterprises) # Fetch will get all information of each enterprise from the server csproot.enterprises.fetch() for enterprise in csproot.enterprises: print(enterprise.name)
def did_receive_push(data): """ Receive delegate """ import pprint pp = pprint.PrettyPrinter(indent=4) pp.pprint(data) if __name__ == '__main__': import sys sys.setrecursionlimit(50) # create a user session for user csproot session = vsdk.NUVSDSession(username="******", password="******", enterprise="csp", api_url="https://localhost:8443") # start the session # now session contains a push center and the connected user session.start() session.reset() session.start() # we get the push center from the session push_center = session.push_center # we register our delegate that will be called on each event push_center.add_delegate(did_receive_push)