def main(): global log format = '%(asctime)s - %(filename)s - %(levelname)s - %(message)s' logging.basicConfig(level=logging.INFO, format=format) log = logging.getLogger(__name__) testbed_filename = '/home/cisco/labpyats/pyats_testbed.yaml' testbed = Genie.init(testbed_filename) commands_to_gather = { 'asa': [ 'show inventory', 'show running-config', 'show route', 'show ospf neighbor', 'show license all' ], 'iosxe': [ 'show inventory', 'show running-config', 'show ip route vrf *', 'show ip ospf neighbor', 'show license feature' ], 'nxos': [ 'show inventory', 'show running-config', 'show ip route vrf all', 'show ip ospf neighbor vrf all', 'show license usage' ] } dir_name = 'gathered_commands' collect_device_commands(testbed, commands_to_gather, dir_name)
def genie_testbed(self, testbed): '''Create the genie testbed''' try: # If pyATS, then call their use_testbed api, then convert self.builtin.get_library_instance('ats.robot.pyATSRobot').\ use_testbed(testbed) testbed = self.builtin.get_library_instance('ats.robot.'\ 'pyATSRobot').testbed except RuntimeError: # No pyATS self.testbed = loader.load(testbed) else: # Has pyATS, so converted and then save locally and also for pyATS self.testbed = Genie.init(testbed) self.builtin.get_library_instance('ats.robot.'\ 'pyATSRobot').testbed =\ self.testbed self.testscript.parameters['testbed'] = self.testbed # Load Genie Datafiles (Trigger, Verification and PTS) # This make UUT mandatory. When learning, aka no trigger # the UUT are not mandatory self.loaded_yamls = True self._load_genie_datafile() if not self.trigger_datafile: self.loaded_yamls = False log.warning("Could not load the Datafile correctly")
def setup(self, testbed): # initalize genie testbed testbed = Genie.init(testbed) # execute check for each device in the testbed using loops device_names = [d for d in testbed.devices.keys()] aetest.loop.mark({{cookiecutter.testcase_class}}Device, uids=device_names, device=testbed.devices.values())
def load(testbed, devices_name): tb = Genie.init(testbed) ret = [] for device in devices_name: try: ret.append(tb.devices[device]) except KeyError as e: raise KeyError("Could not find '{d}' within " "testbed '{tb}'".format(d=device, tb=testbed)) return ret
def setUpClass(cls): testbed = """ devices: R1: os: iosxe type: router connections: {} """ cls.tb = Genie.init(testbed) cls.device = cls.tb.devices['R1'] cls.device.parse = pos_parsed
def get_devices(self, testbed): genie_testbed = Genie.init(testbed) self.parent.parameters["testbed"] = genie_testbed device_list = [] # Attempt to establish connection with each device for device in genie_testbed.devices.values(): if device.os in ["iosxe", "nxos", "iosxr"]: log.info(banner("Connect to device '{d}'".format(d=device.name))) device_list.append(device) # Pass list of devices the to testcases self.parent.parameters.update(dev=device_list)
def genie_init(self, testscript, testbed, uut_alias, helper_alias, steps, context): """ Initialize the environment """ with steps.start('Initializing the environment for' ' Genie Configurable Objects'): # Context to mention which Commnand type to use. (Cli/Yang) # It has to be set before the Genie convertion, as the right # Interface has to be instantiated. # The default value is 'cli', so only do it in the 'yang' case if context == 'yang': # Set all device to yang # Or, only specific device could be set to use 'yang', and the # rest use 'cli' for dev in testbed.devices.values(): dev.context = 'yang' # Initialize Genie Testbed # It also sets the variable 'Genie.testbed', to hold the testbed Genie.init(testbed=testbed) # Test script parameters are added so # these can be passed on to the subsections. uut = Genie.testbed.find_devices(aliases=[uut_alias])[0] helper = Genie.testbed.find_devices(aliases=[helper_alias])[0] testscript.parameters['uut'] = uut testscript.parameters['helper'] = helper # Overwrite the pyATS testbed for Genie Testbed testscript.parameters['testbed'] = Genie.testbed # area_id from the datafile testscript.parameters['area_id'] = self.area_id # Mark testcase with looping information aetest.loop.mark(ping, device=[uut, helper])
def connect(self, testbed): genie_testbed = Genie.init(testbed) self.parent.parameters['testbed'] = genie_testbed device_list = [] for device in genie_testbed.devices.values(): log.info(banner("Connect to device '{d}'".format(d=device.name))) try: device.connect() except Exception as e: self.failed("Failed to establish connection to '{}'".format( device.name)) device_list.append(device) # Pass list of devices the to testcases self.parent.parameters.update(dev=device_list)
def establish_connections(self, testbed): """ Establishes connections to all devices in testbed :param testbed: :return: """ genie_testbed = Genie.init(testbed) self.parent.parameters['testbed'] = genie_testbed for device in genie_testbed.devices.values(): log.info(banner(f"Connect to device '{device.name}'")) try: device.connect(log_stdout=False) except errors.ConnectionError: self.failed(f"Failed to establish " f"connection to '{device.name}'")
def establish_connections(self, testbed): # Load testbed file which is passed as command-line argument genie_testbed = Genie.init(testbed) self.parent.parameters['testbed'] = genie_testbed device_list = [] # Load all devices from testbed file and try to connect to them for device in genie_testbed.devices.values(): log.info(banner(f"Connect to device '{device.name}'")) try: device.connect(log_stdout=False) except errors.ConnectionError: self.failed(f"Failed to establish " f"connection to '{device.name}'") device_list.append(device) # Pass list of devices to testcases self.parent.parameters.update(dev=device_list)
def connect(self, testbed): # Get specified testbed genie_testbed = Genie.init(testbed) # Save in environment variables self.parent.parameters['testbed'] = genie_testbed device_list = [] # Try connect one by one and save device objects in a list for device in genie_testbed.devices.values(): log.info(banner("Connect to device '{d}'".format(d=device.name))) try: device.connect() except Exception as e: self.failed("Failed to establish connection to '{}'".format( device.name)) # Add device to list device_list.append(device) # Pass list of devices the to testcases self.parent.parameters.update(dev=device_list)
def setup(self, testbed): # initalize genie testbed testbed = Genie.init(testbed) self.parent.parameters['testbed'] = testbed # used for tracking neighbor / recovery info self.parent.parameters['failed_nbrs'] = list() self.parent.parameters['recovery_queue'] = list() reason = "being conservative" aetest.skipUnless.affix(section=DoubleCheck, condition=False, reason=reason) aetest.skipUnless.affix(section=Recovery, condition=False, reason=reason) # neighbor check for each device in the testbed using loops aetest.loop.mark(CheckForNeighbor, device=testbed.devices)
def connect(self, testbed): genie_testbed = Genie.init(testbed) self.parent.parameters['testbed'] = genie_testbed device_list = [] for d in genie_testbed.devices.keys(): # Mark testcase with looping information device = genie_testbed.devices[d] log.info(banner("Connect to device '{d}'".format(d=device.name))) try: device.connect() device_list.append(d) except Exception as e: msg = "Failed to connect to {} will not be checked!" log.info(msg.format(device.name)) # run local_user_check against each device in the list aetest.loop.mark(local_user_check, dev_name=device_list)
def validate_testbed(self, testbed): ''' basic checks of the testbed file ''' # abort/fail the testscript if no testbed was provided if not testbed or not testbed.devices: self.failed('No testbed was provided to script launch', goto=['exit']) # abort/fail the testscript if no matching device was provided if 'dist1' not in testbed: self.failed('testbed needs to contain device `dist1`', goto=['exit']) genie_testbed = Genie.init(testbed) dist1 = genie_testbed.devices['dist1'] # add device to testscript parameters so we can use it later self.parent.parameters.update(dist1=dist1)
def main(): parser = argparse.ArgumentParser(description="standalone parser") parser.add_argument('--testbed', dest='testbed', type=loader.load) parser.add_argument('--neighbor', help="Expected neighbor RID") args, unknown = parser.parse_known_args() if not all([args.testbed, args.neighbor]): print(banner("Please specify a testbed file and expected neighbor")) else: # pyats testbed != genie testbed testbed = Genie.init(args.testbed) nbr = args.neighbor uut = testbed.devices['uut'] uut.connect() # Retrieve Ospf Class for this device ospf_cls = get_ops('ospf', uut) # Instantiate the class, and provides some attributes # Attributes limit the # of clis to use; # It will only learn the neighbors, nothing else. ospf = ospf_cls(uut, attributes=['info[vrf][(.*)][address_family][ipv4]' '[instance][{OSPF_PROCESS}]' '[areas][{OSPF_AREA}]' '[interfaces][{EXPECTED_INTERFACE}]' '[neighbors][(.*)]'\ .format(OSPF_PROCESS=OSPF_PROCESS, OSPF_AREA=OSPF_AREA, EXPECTED_INTERFACE=EXPECTED_INTERFACE)]) ospf.learn() state = check_for_neighbor(ospf, nbr) if state: print( banner("Successfully verified neighbor {} is {}".format( nbr, state))) else: print(banner("Failed to verify neighbor, now what?"))
def connect(self, testbed, MAX_POOL_SIZE=31): genie_testbed = Genie.init(testbed) self.parent.parameters['testbed'] = genie_testbed uut = genie_testbed.devices['uut'] # Create a connection pool if hasattr(testbed, 'custom') and hasattr(testbed.custom, 'MAX_POOL_SIZE'): MAX_POOL_SIZE = testbed.custom.MAX_POOL_SIZE uut.start_pool(alias='pool', size=MAX_POOL_SIZE) # A Connection pool workers need to have genie attributes to be able to # call ops for worker in uut.pool.workers: worker.mapping = {} worker.mapping['cli'] = 'vty' worker.cli = worker # Pass 'uut' to testcases self.parent.parameters.update(dev=uut)
def genie_testbed(self, testbed): '''Create the genie testbed''' try: # If pyATS, then call their use_testbed api, then convert self.builtin.get_library_instance('ats.robot.pyATSRobot').\ use_testbed(testbed) testbed = self.builtin.get_library_instance('ats.robot.'\ 'pyATSRobot').testbed except RuntimeError: # No pyATS self.testbed = loader.load(testbed) else: # Has pyATS, so converted and then save locally and also for pyATS self.testbed = Genie.init(testbed) self.builtin.get_library_instance('ats.robot.'\ 'pyATSRobot').testbed =\ self.testbed self.testscript.parameters['testbed'] = self.testbed # Load Genie Datafiles (Trigger, Verification and PTS) self._load_genie_datafile()
def connect(self, testbed, steps): genie_testbed = Genie.init(testbed) device_list = [] device_name = [] for device in genie_testbed.devices.values(): with steps.start( "Connecting to device '{d}'".format(d=device.name)): log.info( banner("Connecting to device '{d}'".format(d=device.name))) try: device.connect() except Exception as e: self.failed( "Failed to establish connection to '{}'".format( device.name)) device_list.append(device) device_name.append(device.name) log.info((device_list)) aetest.loop.mark(device_commands, devices=device_list, uids=device_name)
def get_details(): # Load the testbed of devices and credentials testbed = Genie.init('testbed.yml') global results # Using Genie to gather the data from the devices and store in a list of lists. for name in testbed.devices: testbed.devices[name].connect() version = testbed.devices[name].parse("show version") # If is NXOS as uses completely different data structure if 'platform' in version.keys(): dev_table = [name, version['platform']['os'], version['platform']['hardware']['chassis'], version['platform']['software']['system_version'], version['platform']['hardware']['processor_board_id']] # If is IOSXE as chassis different in IOSXE and IOS data structures elif version['version']['os'] == 'IOS-XE': dev_table = [name, version['version']['os'], version['version']['chassis'], version['version']['version_short'], version['version']['chassis_sn']] # IF IOSv elif version['version']['os'] == 'IOSv': dev_table = [name, version['version']['os'], version['version']['platform'], version['version']['version_short'], version['version']['chassis_sn']] # Creates a list of lists of all devices results.append(dev_table) testbed.devices[name].disconnect()
copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ # Import the Genie library from genie.conf import Genie # Create a testbed object testbed = Genie.init("testbed.yaml") # Take a look at the devices that are in the testbed print(testbed.devices) # Create a "convenience" variable for one device iosv1 = testbed.devices["iosv-1"] # Connect to the router iosv1.connect() # Check that you are connected iosv1.connected # Run the "show interfaces" command and "parse" results to Python object interfaces = iosv1.parse("show interfaces")
} }, ) build_device = Device( os.getenv("SWITCH_HOSTNAME"), os="nxos", type="nxos", connections={ "default": { "protocol": "ssh", "ip": os.getenv("SWITCH_MGMT_IP") } }, ) build_device.testbed = build_testbed genie_testbed = Genie.init(build_testbed) # Grab the device and connect device = genie_testbed.devices[os.getenv("SWITCH_HOSTNAME")] device.connect(learn_hostname=True, log_stdout=False) def platform_info(): return device.learn("platform") def interfaces_current(): interfaces = device.learn("interface") return interfaces.info
copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ # Import Genie from genie.conf import Genie # Initialize a Testbed File testbed = Genie.init("genie-testbed.yaml") # Create variable for specific testbed device device = testbed.devices["csr1000v-1"] # Conenct to the device device.connect() # Learn the interfaces using Genie model interfaces = device.learn("interface") # Print out interface name print("Here are the interfaces from device {}".format(device.name)) for interface in interfaces.info: print(interface)
import os from genie.conf import Genie # import the topology module from ats.topology import loader # import the genie libs from genie.abstract import Lookup from genie.libs import ops # load testbed file which describes our devices pyats_testbed = loader.load('./default_testbed.yaml') # pyats testbed != genie testbed genie_testbed = Genie.init(pyats_testbed) print(genie_testbed.devices) all_interfaces = dict() for name, device in genie_testbed.devices.items(): print("Gathering Interface Information from {}".format(name)) device.connect() abstract = Lookup.from_device(device) intf = abstract.ops.interface.interface.Interface(device) intf.learn() all_interfaces[name] = intf.info for device, ints in all_interfaces.items(): for name, props in ints.items(): counters = props.get('counters') if counters: print('{}:{} CRC Errors: {}'.format(device, name, counters['in_crc_errors']))
# from testbed_from_inventory import create_testbed # import configparser from genie.abstract import Lookup from genie.libs import ops # noqa from genie.conf import Genie from prettytable import PrettyTable import re import pprint testbed = Genie.init('tests/testbed.yml') device = testbed.devices['fspipswi001'] # Conenct to the device device.connect() interfaces = device.parse("show interfaces") switchports = device.parse("show interfaces switchport") ntp = device.parse("show ntp associations") interface_list = {} for intf, v in interfaces.items(): if 'description' in v: decsc = v['description'] else: decsc = None if not 'Vlan' in intf: intf_obj = {} intf_obj[intf] = { 'description': decsc, 'access_vlan': switchports[intf]['access_vlan'],
from genie.conf import Genie print( "Running script that applies a configuration change to device 'edge-sw01'." ) print("The device 'edge-sw01' is defined in the testbed-file.") # Carrega o testebed com todos os devices testbed = Genie.init('multi-platform-network.yaml') # Conecta ao device 'edge-sw01' device = 'edge-sw01' testbed.devices[device].connect(log_stdout=False) # Aplica a mudança de configuração testbed.devices[device].configure( ["interface Loopback799", "description Nova Interface Criada Via Script"]) # Desconecta testbed.devices[device].disconnect() print("Changes applied.") print("We can now compare the current configuration against the previous one.")
# local imports import argparse parser = argparse.ArgumentParser(description="standalone parser") parser.add_argument('--testbed', default='./default_testbed.yaml', dest='testbed', type=loader.load) parser.add_argument('--device', dest='device_name') args, unknown = parser.parse_known_args() print(args) device_name = args.device_name # pyats testbed != genie testbed genie_testbed = Genie.init(args.testbed) # this gives us device_name as Device Object e.g dist1 vars()[device_name] = genie_testbed.devices[device_name] # or we can also just use `device` device = vars()[device_name] # connect to the device device.connect() # work with an abstracted device model abstract = Lookup.from_device(device) # interface info is always a good place to start.. interfaces = abstract.ops.interface.interface.Interface(device) interfaces.learn()
import os import sys import pprint from nornir_jinja2.plugins.tasks import template_file from genie import testbed from pyats import topology from genie.conf import Genie from pyats.topology import loader testbedfile = os.path.join('../testbed.yml') testbed = Genie.init(testbedfile) def verify_vlan(task): device = testbed.devices[f'{task.host}'] device.connect(log_stdout=False) output = device.parse('show vlan') available_vlans = output['vlans'].keys() configured_vlans = [10, 22, 35, 40, 44] result_dict = {} for vlan_id in configured_vlans: if vlan_id in available_vlans: result_dict.update({f"Vlan {vlan_id} present": True}) else: result_dict.update({f"Vlan {vlan_id} present": False}) if False in result_dict.values(): raise Exception(["Vlans not properly configured", result_dict]) else: return result_dict
# cmdRouter.csv file must exist in current working directory # Example of cmdRouter.csv: # command/rustphrbtqfb-1.txt,rustphrbtqfb-1 # command/rustphrbtqfb-2.txt,rustphrbtqfb-2 #Import neccessary libraries/modules import pickle import sys import pprint from ats.topology import loader from genie.conf import Genie import csv #Define global variables testbed = loader.load('my_testbed.yaml') #Load testbed yaml file genie_testbed = Genie.init(testbed) #Init genie testbed logfile = open('log.txt', 'w+') #Open log file #Define readCommandRouterFile() --- read csv file & return to data structure obj def readCommandRouterFile(cmdRouterFile): with open(cmdRouterFile) as f: csvf = csv.reader(f) data = list(csvf) return data #Define readCommandFile() --- read command txt file & return to cmd structure obj def readCommandFile(cmdFile): with open(cmdFile) as f: cmd = f.read().splitlines() return cmd
def main(): parser = argparse.ArgumentParser(description="standalone parser") parser.add_argument('--testbed', dest='testbed', type=loader.load) args, unknown = parser.parse_known_args() if not args.testbed: print(""" ************************************************************** You didn't specify a testbed, we'll load up a Devnet sandbox. Next time try with your own testbed file by running ipyats --testbed <your file> ************************************************************** """) path = os.path.abspath(os.path.join(ipyats.__file__, os.pardir)) testbed = path + '/public_testbeds/devnet_sandbox.yaml' testbed = loader.load(testbed) testbed = Genie.init(testbed) else: # pyats testbed != genie testbed testbed = Genie.init(args.testbed) print(""" Welcome to ipyATS! your testbed is now available as the `testbed` object You can start by exploring some of the common operations available for the testbed by typing dir(testbed) To get you started, we've also included some common tasks, give them a try and then checkout the code in the `tasks` folder dir(tasks) You can checkout the source code for any of these funtions by passing them to show_source e.g show_source(tasks.get_routing_table) """) # if it's sandbox, these will come in handy if testbed.name == "devnet_always_on_sandbox": csr = testbed.devices['csr1000v'] # noqa nx = testbed.devices['sbx-n9kv-ao'] # noqa print(""" Detected Always-On Sandbox, creating some handy objects Created objects `csr` and `nx`") csr = testbed.devices['csr1000v'] nx = testbed.devices['sbx-n9kv-ao'] """) # bail to iPython embed()
from genie.conf import Genie testbed = '/pyats/demos/default_testbed.yaml' testbed = Genie.init(testbed) # select a specific device from the testbed definition csr = testbed.devices['csr1000v-1'] # connect to that device csr.connect() # execute a command in that device csr.execute('show version')