def get_credentials(ztp=cvp_vars.getValue(cvp_names.ZTP_STATE)): if ztp == 'true': user = cvp_vars.getValue(cvp_names.ZTP_USERNAME) pwd = cvp_vars.getValue(cvp_names.ZTP_PASSWORD) else: user = cvp_vars.getValue(cvp_names.CVP_USERNAME) pwd = cvp_vars.getValue(cvp_names.CVP_PASSWORD) return (user, pwd)
def get_credentials(ztp=GV.getValue(GVN.ZTP_STATE)): if ztp == 'true': user = GV.getValue(GVN.ZTP_USERNAME) pwd = GV.getValue(GVN.ZTP_PASSWORD) else: user = GV.getValue(GVN.CVP_USERNAME) pwd = GV.getValue(GVN.CVP_PASSWORD) return (user, pwd)
def modifyACL(acl_name, modify_action, acl_statements, acl_interface_application, apply_interface, remove_interface, apply_directions, remove_directions, device_ips, preview_or_apply): username = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME) password = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD) server = CVP('localhost', username, password) server.login() if modify_action == "Create/Update" or acl_interface_application is not None: CreateOrUpdateACL(acl_name, acl_statements, acl_interface_application, apply_interface, remove_interface, apply_directions, remove_directions, device_ips, preview_or_apply, server) elif modify_action == "Delete": DeleteACL(acl_name, device_ips, preview_or_apply, server) server.logout()
def showAclDetails(device_ips, acl_name): output = "" user = SSHClientUser(CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME), CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD)) sshclient = SSHClient(user, device_ips[0]) cmd = 'sh ip access-lists %s' %(acl_name) resp = sshclient.executeCommand( cmd ) output += resp cmd = 'sh ip access-lists %s summary | json' %(acl_name) resp = json.loads(sshclient.executeCommand( cmd ) ) configured_egress_interfaces = [] configured_ingress_interfaces = [] for iface in resp["aclList"][0]["configuredEgressIntfs"]: configured_egress_interfaces.append(iface["name"]) for iface in resp["aclList"][0]["configuredIngressIntfs"]: configured_ingress_interfaces.append(iface["name"]) output += "Configured Egress Interfaces\n" if len(configured_egress_interfaces) == 0: output += " None\n" for iface in configured_egress_interfaces: output += " - {}\n".format(iface) output += "\n" output += "Configured Ingress Interfaces\n" if len(configured_ingress_interfaces) == 0: output += " None\n" for iface in configured_ingress_interfaces: output += " - {}\n".format(iface) output += "\n" print output
def send_commands(commands): ip = cvp_vars.getValue(cvp_names.CVP_IP) usr, pwd = get_credentials() connection_url = 'http://%s:%s@%s/command-api' % (usr, pwd, ip) conn = jsonrpclib.Server(connection_url) result = conn.runCmds(1, commands) return result
def get_leaf_routed_ips(routed_ints): user, pwd = get_credentials() sw_ip = GV.getValue(GVN.CVP_IP) commands = list() commands.append('show lldp neighbors detail') lldp_info = send_command(user, pwd, sw_ip, commands)[0]['lldpNeighbors'] neighbors = dict() for rint in routed_ints: sw_name = lldp_info[rint]['lldpNeighborInfo'][0]['systemName'].split('.')[0] sw_mac = lldp_info[rint]['lldpNeighborInfo'][0]['chassisId'].replace('.','') sw_mac = ':'.join(a+b for a,b in zip(sw_mac[::2], sw_mac[1::2])) if sw_name not in neighbors.keys(): neighbors[sw_name] = dict() port = lldp_info[rint]['lldpNeighborInfo'][0]['neighborInterfaceInfo']['interfaceId'].replace('"','') if port not in neighbors[sw_name].keys(): neighbors[sw_name][port] = dict() neighbors[sw_name][port]['leaf_if'] = rint neighbors[sw_name][port]['spine_ip'] = '' neighbors[sw_name][port]['leaf_ip'] = '' neighbors[sw_name]['spine_mac'] = sw_mac for device in neighbors.keys(): commands = list() for intf in neighbors[device].keys(): if 'spine_mac' != intf: commands.append('show ip interface {0}'.format(intf)) node = get_net_element(neighbors[device]['spine_mac']) _user, _pwd = get_credentials(node['ztpMode']) ip_info = send_command(_user, _pwd, node['ipAddress'], commands) for ip_intf in ip_info: intf = ip_intf['interfaces'].keys()[0] ip = ip_intf['interfaces'][intf]['interfaceAddress']['primaryIp']['address'] neighbors[device][intf]['spine_ip'] = ip octect = ip.split('.') fourth = int(octect[3]) + 1 leaf_ip = '{0}.{1}.{2}.{3}'.format(octect[0], octect[1], octect[2], fourth) neighbors[device][intf]['leaf_ip'] = leaf_ip routed_info = list() for device in neighbors.keys(): for intf in neighbors[device].keys(): if 'spine_mac' != intf: leaf_if = neighbors[device][intf]['leaf_if'] leaf_ip = neighbors[device][intf]['leaf_ip'] spine_ip = neighbors[device][intf]['spine_ip'] routed_info.append((leaf_if, device, intf.replace('/','_'), leaf_ip, spine_ip)) return routed_info
def main(): if CVPGlobalVariables.getValue( GlobalVariableNames.ZTP_STATE ) == 'true': # If device in ztp state, continue. device_ip = CVPGlobalVariables.getValue( GlobalVariableNames.CVP_IP) # Get Device IP device_user = CVPGlobalVariables.getValue( GlobalVariableNames.ZTP_USERNAME) # Get CVP temp username for ZTP. device_pass = CVPGlobalVariables.getValue( GlobalVariableNames.ZTP_PASSWORD) # Get CVP temp password for ZTP. device = Device( device_ip, device_user, device_pass) # Create eAPI session to device via Device library. currentVersion = device.runCmds( ['enable', 'show version'])[1]['response'][ 'version'] # Get currently installed version of device if currentVersion == image_to_downgrade: # If device version is same as image_to_downgrade var, try to downgrade it. if cvp_image == 'undefined': EOSImage = get_undefined_image() else: EOSImage = specific_image try: print 'Uploading EOS version ' + EOSImage + ' to device ' + device_ip device.runCmds(['enable', cvpInstallImage + EOSImage]) print 'Checking Boot Vars on device ' + device_ip bootvar = device.runCmds(['enable', 'show boot' ])[1]['response']['softwareImage'] if bootvar.endswith(EOSImage): print 'Boot Var matches installed image. Rebooting now.' try: device.runCmds(['enable', 'reload now']) except: pass except: pass else: pass
def showAclNames(device_ips): user = SSHClientUser(CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME), CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD)) sshclient = SSHClient(user, device_ips[0]) cmd = 'sh ip access-lists | json' resp = sshclient.executeCommand( cmd ) resp_json = json.loads(resp) acl_names = [] for acl in resp_json["aclList"]: if acl["dynamic"] == False and acl["readonly"] == False: acl_names.append( acl["name"] ) if len(acl_names) == 0: print "No configured ACLs found" for name in acl_names: print name
def sendCmd(commands): ztp = cvpGV.getValue(GVN.ZTP_STATE) hostip = cvpGV.getValue(GVN.CVP_IP) if ztp == 'true': user = cvpGV.getValue(GVN.ZTP_USERNAME) passwd = cvpGV.getValue(GVN.ZTP_PASSWORD) else: user = cvpGV.getValue(GVN.CVP_USERNAME) passwd = cvpGV.getValue(GVN.CVP_PASSWORD) url = "https://%s:%s@%s/command-api" % (user, passwd, hostip) switch = jsonrpclib.Server(url) response = switch.runCmds(1, commands)[0] return response
def get_routed_info(interfaces): routed_info = list() user, pwd = get_credentials() sw_ip = cvp_vars.getValue(cvp_names.CVP_IP) commands = ['show lldp neighbors detail'] lldp_info = send_command(user, pwd, sw_ip, commands)[0]['lldpNeighbors'] for _int in interfaces: lldp_neigh = lldp_info[_int]['lldpNeighborInfo'][0] neigh_mac = lldp_neigh['chassisId'].replace('.', '') neigh_mac = ':'.join(a + b for a, b in zip(neigh_mac[::2], neigh_mac[1::2])) neigh_int = lldp_neigh['neighborInterfaceInfo']['interfaceId'].replace( '"', '') node = get_net_element(neigh_mac) _user, _pwd = get_credentials(node['ztpMode']) _commands = ['show ip interface %s' % neigh_int] int_info = send_command(_user, _pwd, node['ipAddress'], _commands)[0]['interfaces'] cidr = int_info[neigh_int]['interfaceAddress']['primaryIp']['maskLen'] neigh_ip = int_info[neigh_int]['interfaceAddress']['primaryIp'][ 'address'] ip_info = neigh_ip.split('.') local_ip = '%s.%s' % ('.'.join(ip_info[:3]), str(int(ip_info[-1]) + 1)) entry = dict() entry['localInt'] = _int entry['localIp'] = local_ip entry['neighMac'] = neigh_mac entry['neighInt'] = neigh_int entry['neighIp'] = neigh_ip entry['cidr'] = cidr entry['systemName'] = node['fqdn'].split('.')[0] routed_info.append(entry) return routed_info
def get_interfaces(): ## If interfaces need to be excluded, add to exempt_ints exempt_ints = list() exempt_ints.append('Management0') exempt_ints.append('Management1') exempt_ints.append('Management1/1') exempt_ints.append('Management1/2') exempt_ints.append('Management2/1') exempt_ints.append('Management2/2') interfaces = list() user, pwd = get_credentials() sw_ip = cvp_vars.getValue(cvp_names.CVP_IP) commands = ['show interfaces status'] int_status = send_command(user, pwd, sw_ip, commands)[0]['interfaceStatuses'] for key in int_status.keys(): if key in exempt_ints: continue else: interfaces.append(key) return sorted(interfaces)
import yaml import requests import json from cvplibrary import CVPGlobalVariables, GlobalVariableNames from cvplibrary import Device #Revision 0.4 device_ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) dev_user = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME) dev_pass = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD) def authenticate(): #Send username and password via API and get session ID in cookies in order to use for future API calls. #Login API Url authUrl = "https://localhost/web/login/authenticate.do" #Create JSON object with username and password. authPayload = '''{ "userId": \"%s\", "password": \"%s\" }''' % (dev_user, dev_pass) #Establish connection headers headers = { 'Content-Type': "application/json", 'cache-control': "no-cache", } #Perform API call for authentication and log response as a variable.
def build_allocations(session, pools): allocs = get_network_allocations(session, 'overlay', 'ipv4')['data'] for item in allocs: desc = item['description'] parent = item['parentsubnet'] if desc in pools[parent]['allocations'].keys(): continue else: pools[parent]['allocations'][desc] = item return pools session = get_session_id() sys_mac = cvp_vars.getValue(cvp_names.CVP_MAC) systems = get_systems(session) sys_hostname = systems[sys_mac] asns = build_asns(session) sys_asn = asns[sys_hostname] pools = build_pools(session, 'overlay-ipv4') pools = build_allocations(session, pools) vrfs = set() vxlan_vlans = dict() flood_list = set() vtep = netaddr.IPNetwork(pools['%s_vtep' % sys_hostname]['range']) varp_vtep = netaddr.IPNetwork(pools['varp_vtep']['range']) for key in pools.keys(): if 'group' in pools[key].keys() and 'vlan' in pools[key].keys():
try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: # Legacy Python that doesn't verify HTTPS certificates by default pass else: # Handle target environment that doesn't support HTTPS verification ssl._create_default_https_context = _create_unverified_https_context # # Get all data from Form spine1_port_num = Form.getFieldById('spine1_port_num').getValue() spine2_port_num = Form.getFieldById('spine2_port_num').getValue() spine3_port_num = Form.getFieldById('spine3_port_num').getValue() ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) myCVPuser = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME) myCVPpasswd = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD) # # Username/password/protocol for eAPI access to switches # EAPI_USERNAME = myCVPuser EAPI_PASSWORD = myCVPpasswd EAPI_METHOD = 'https' # # Via eAPI call get detect unique loopback ip address use to derive fabric interfaces ##!!Changing "unique_loopback_ip to call loopback0 for Jasons Lab!!" switch = Server('%s://%s:%s@%s/command-api' %
from netaddr import * import json import yaml import re from jinja2 import Template import requests from cvplibrary import RestClient import ssl from cvplibrary import CVPGlobalVariables, GlobalVariableNames device_sn = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_SERIAL) # Ignore untrusted certificate for eAPI call. ssl._create_default_https_context = ssl._create_unverified_context ### CVP REST - Puts Configlets in CVP. cvpserver = 'https://localhost:443' rest_get_configlet_by_name = '/cvpservice/configlet/getConfigletByName.do?name=' ### YAML Locationrest_get_configlet_by_name = '/cvpservice/configlet/getConfigletByName.do?name=' # YAML can either be stored in CVP directly or off-box on an http url. yaml_location = 'cvp' # 'http' | 'cvp' ## http storage. Define the full requests url. if yaml_location == 'http': yaml_http = requests.get( 'http://gitlab.example.com/root/YamlBuilder/raw/master/example.yaml') yamlfile = yaml_http.text ## CVP Storage - define yaml_configlet as the name of the configlet. if yaml_location == 'cvp':
import urllib3 import json import yaml import jinja2 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) ###################Define Global Variables################### username = '******' password = '******' cvp_server = '10.0.0.14' api_headers = { 'Content-Type': "application/json", 'cache-control': "no-cache", } api_root = 'https://{0}/web'.format(cvp_server) device_ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) ############################################################# def authenticate(): url_path = api_root + '/login/authenticate.do' payload = {"userId": username, "password": password} response = requests.request('POST', url_path, data=json.dumps(payload), headers=api_headers, verify=False) return (response.cookies)
import jsonrpclib from cvplibrary import CVPGlobalVariables, GlobalVariableNames ztp = CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_STATE) ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) if ztp == 'true': user = CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_USERNAME) passwd = CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_PASSWORD) else: user = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME) passwd = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD) def get_hostname(): url = "https://%s:%s@%s/command-api" % (user, passwd, ip) ss = jsonrpclib.Server(url) show_hostname = ss.runCmds(1, ["enable", {"cmd": "show hostname"}])[1] hostname = show_hostname['hostname'] return hostname def create_routes(hostname): number = hostname[-1:] if hostname.startswith("leaf"): switch_type = "10" elif hostname.startswith("spine"): switch_type = "20" for x in range(100, 200): print "int lo%d" % (x)
import ssl try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: # Legacy Python that doesn't verify HTTPS certificates by default pass else: # Handle target environment that doesn't support HTTPS verification ssl._create_default_https_context = _create_unverified_https_context ssl._create_default_https_context = ssl._create_unverified_context import requests.packages.urllib3 requests.packages.urllib3.disable_warnings() cvp_username = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME) cvp_password = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD) clnt = CvpClient() clnt.connect(['localhost'], cvp_username, cvp_password) configlet_name = "cvp_1_site_users_pwd_config" output = clnt.api.get_configlet_by_name(name = configlet_name) config = output["config"] key = output["key"] new_config = "" for line in config.splitlines(): if "secret" in line or "enable" in line: words = line.split()
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN # IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """Multicast Auto Reconcile Configlet Builder This Python code must be used as configlet builder on CVP It helps to reconcile the config produced by M&E controller (multicast routes) automatically. This builder can be triggered before executing the change by trigger-mcast-reconcile.py """ __author__ = 'Petr Ankudinov' from cvplibrary import CVPGlobalVariables, GlobalVariableNames, Device from time import time # find device IP device_ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) device_serial = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_SERIAL) # find username and password ztp = CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_STATE) if ztp == 'true': user = CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_USERNAME) passwd = CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_PASSWORD) else: user = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME) passwd = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD) device = Device(device_ip, username=user, password=passwd) cmdList = ['enable', 'show running-config'] # get `router multicast` config section mcast_config = device.runCmds(cmdList)[1]['response']['cmds'][ 'router multicast']['cmds']['ipv4']['cmds'].keys()
from cvplibrary import Form from cvplibrary import CVPGlobalVariables, GlobalVariableNames from cvplibrary import RestClient import sys def netid_to_serialnum(net_id): query = 'http://localhost:8080/web/provisioning/getNetElementById.do?netElementId=%s' % mac client = RestClient(query, 'GET') if client.connect(): dev_info = json.loads(client.getResponse()) return dev_info['serialNumber'] return None mac = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_MAC) serialnum = netid_to_serialnum(mac) with open('mgmt_applicator.csv', 'rb') as f: reader = csv.reader(f) sertohost = list(reader) # Capturing the hostname of the device for items in sertohost: if items[0] == serialnum and items[1].startswith(('as', 'sw')): hostname = items[1] with open('bgpfile.csv', 'rb') as f: reader = csv.reader(f) bgpinfo = list(reader) # Capturing hostnames of all BGP hosts here bgp_col1 = set()
import jsonrpclib import json import requests # Set Form Variables and static lo0 = Form.getFieldById('lo0').getValue() lo0 = netaddr.IPNetwork('%s/32' % lo0) lo1 = Form.getFieldById('lo1').getValue() lo1 = netaddr.IPNetwork('%s/32' % lo1) lo1_sec = Form.getFieldById('lo1_sec').getValue() lo1_sec = netaddr.IPNetwork('%s/32' % lo1_sec) mlag_subnet = Form.getFieldById('mlag_subnet').getValue() mlag_subnet = netaddr.IPNetwork(mlag_subnet) leaf_asn = Form.getFieldById('leaf_asn').getValue() spine_asn = Form.getFieldById('spine_asn').getValue() mac = cvp_vars.getValue(cvp_names.CVP_MAC) routed_ints = list() routed_ints.append('Ethernet2') routed_ints.append('Ethernet3') mlag_peer_ints = list() mlag_peer_ints.append('Ethernet1') mlag_ints = list() mlag_ints.append('Ethernet4') # Functions to build leaf configuration def get_net_element(system_mac): url = 'http://localhost:8080/cvpservice/provisioning/getNetElementById.do?netElementId=%s' % system_mac client = RestClient(url, 'GET') client.connect() node_info = json.loads(client.getResponse())
def main(): device_ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) # Get Device IP device = Device(device_ip,device_user,device_pass) # Create eAPI session to device via Device library. reboot = device.runCmds(['enable','write','reload now']) # Get currently installed version of device
from cvplibrary import Form from jsonrpclib import Server from cvplibrary import CVPGlobalVariables, GlobalVariableNames #fetching the management ip of the current device device_ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) #fetching the username for the current device username = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_USERNAME) #fetching the password for the current device password = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_PASSWORD) #fetching the variables from the form intvlan_var = Form.getFieldById("field_1").getValue() vrf_var = Form.getFieldById("field_2").getValue() ipaddrv = Form.getFieldById("field_3").getValue() print "vrf definition " + vrf_var print "vlan " + intvlan_var print "interface vlan " + intvlan_var print "mtu 9000" print "no autostate" print "vrf forwarding " + vrf_var print "ip address virtual " + ipaddrv + "/24" print "interface Vxlan1" print "vxlan vlan " + intvlan_var + " vni " + intvlan_var #connecting to the switch switch = Server('https://%s:%s@%s/command-api' % (username, password, device_ip))
configletPrefix = 'techspt_' commandList = [ 'show ip bgp summary', 'show ip arp', 'show bgp evpn summary', 'show mac address-table', 'show tech-support' ] overwrite_configlets = True # Set to False if you want to protect configlets from overwrite. # Ignore untrusted certificate for eAPI call. ssl._create_default_https_context = ssl._create_unverified_context ### CVP REST - Puts Configlets in CVP. cvpserver = 'https://*****:*****@%s/command-api" % (user, passwd, device_ip) ss = jsonrpclib.Server(url) HTTP_TIMEOUT = 120 def check_configlet_exists(configlet_name): client = RestClient( cvpserver + rest_get_configlet_by_name + configlet_name, 'GET') if client.connect(): output = json.loads(client.getResponse()) if 'errorCode' in output:
import json import re from cvplibrary.auditlogger import alog from cvplibrary import Device, CVPGlobalVariables, GlobalVariableNames ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) serial = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_SERIAL) session_id = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_SESSION_ID) scriptArgs = CVPGlobalVariables.getValue(GlobalVariableNames.SCRIPT_ARGS) alog("Remove all old EOSs from /mnt/flash") switch = Device(ip) # Get current boot image cmdOut = switch.runCmds(["show boot"]) eosBootImageFull = cmdOut[0]["response"]["softwareImage"] eosBootImage = eosBootImageFull.split("/")[1] cmdOut = switch.runCmds(["dir flash:EOS*"]) eosListTxt = cmdOut[0]["response"]["messages"][0] eosList = re.findall(r'EOS.*\.swi', eosListTxt) for eos in eosList: if eos != eosBootImage: cmd = "delete flash:" + eos cmdOut = switch.runCmds([cmd])
""" This script is used to create BGP configurations within the L3 leaf and spine topology. """ import sys sys.path.append('/usr/lib64/python2.7/site-packages/') import yaml from cvplibrary import CVPGlobalVariables as cvpGV from cvplibrary import GlobalVariableNames as GVN #Variable declarations yFile = 'hostvars/dc1.yml' smac = cvpGV.getValue(GVN.CVP_MAC) yaml_file = open(yFile) infoY = yaml.load(yaml_file) yaml_file.close() shost = infoY['device'][smac] #Grabbing sections of the YAML file curINT = infoY['configurations'][shost]['interfaces'] curBGP = infoY['configurations'][shost]['BGP'] lloopINT = None try: lloopINT = curINT['loopback']['Loopback0']['ip'] lloopINTN = '%s/%s' % (lloopINT, curINT['loopback']['Loopback0']['cidr']) except: pass
from cvplibrary import CVPGlobalVariables, GlobalVariableNames, Device vlanRangeStart = '4000' vlanRangeEnd = '4094' # Check if Device is in ZTP Mode: if CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_STATE) == 'true': device_ip = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) device_user = CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_USERNAME) device_pass =CVPGlobalVariables.getValue(GlobalVariableNames.ZTP_PASSWORD) device = Device(device_ip,device_user,device_pass) iflist = device.runCmds(['enable','show interfaces status'])[1]['response'] vlanOrder = device.runCmds(['enable', 'configure', 'vlan internal order ascending range '+vlanRangeStart+' '+vlanRangeEnd]) for item in iflist['interfaceStatuses'].keys(): if item.startswith('Ethernet'): device.runCmds(['enable','configure','interface '+item,'shutdown']) device.runCmds(['enable','configure','interface '+item,'no shutdown']) else: pass #end device set-up.
test = False if not RequestSession.getSessionId(): test = True # Log message handling def outMsg(test,msgTxt): """ Output log messages to stdout if testing or CVP CC log if running in CVP """ if test: print(msgTxt) else: alog(msgTxt) # Create Script variables scriptArgs = CVPGlobalVariables.getValue( GlobalVariableNames.SCRIPT_ARGS) scriptArgs['deviceList']=re.split(',',scriptArgs['deviceList']) # Internal Variables host_port = 22 passed = 0 failed = 0 # Write entry to Log outMsg(test, "page_check - check Web Page connectivity") # Intialise SSH ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # Start ping tests from devices in deviceList
""" This script is used to create L3 interfaces for ethernet, svi's, and loopback interfaces. """ import sys sys.path.append('/usr/lib64/python2.7/site-packages/') import yaml from cvplibrary import CVPGlobalVariables as cvpGV from cvplibrary import GlobalVariableNames as GVN #Variable declarations yFile = 'hostvars/dc1.yml' virtual_MAC = '00:1c:73:00:00:99' select_mac = cvpGV.getValue(GVN.CVP_MAC) sIP = cvpGV.getValue(GVN.CVP_IP) yaml_file = open(yFile) info_yaml = yaml.load(yaml_file) yaml_file.close() shost = info_yaml['device'][select_mac] #Grabbing sections of the YAML file device_interfaces = info_yaml['configurations'][shost]['interfaces'] list_device_interfaces = [] #dict_loopback_interfaces = {} list_svi_interfaces = [] VARP = False #L3 ethernet interfaces
alog(string) - alog function writes the string to the audit logs tagged with the specific change control calling the script Smaple yaml file name : check_switchType args: switchType : vEOS """ # Import required Librarys import json from cvplibrary.auditlogger import alog # CVP auit log function from cvplibrary import Device, CVPGlobalVariables, GlobalVariableNames # CVP Variables # Create Script variables ipAddress = CVPGlobalVariables.getValue(GlobalVariableNames.CVP_IP) scriptArgs = CVPGlobalVariables.getValue(GlobalVariableNames.SCRIPT_ARGS) # Write entry to Log alog("running show version from script to check switch type") # Connect to Device specified in Change Control switch = Device(ipAddress) # Run show commands on switch cmdOut = switch.runCmds(["show version", "show hostname"]) # Check if the switch type is correct if str(scriptArgs['switchType']) not in cmdOut[0]["response"]["modelName"]: logTxt = "WARNING: switch %s is not a %s it is a %s" % ( cmdOut[1]["response"]["hostname"], scriptArgs['switchType'], cmdOut[0]["response"]["modelName"]) alog(logTxt) assert (False)