devnet2449.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# DEVNET-2449 Python For the Enterprise Automation Exloration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Jupyter Notebooks\n",
    "The *Jupyter Notebooks* in this workbench class are interactive learning environments. We are using them to learn about network device programability in combination with virtual Cisco network devices.\n",
    "\n",
    "Notebooks are **interactive**, the code and text in each notebook can be changed on the fly and the result of those changes can be seen immediately within the notebook itself.\n",
    "\n",
    "Notebooks are organized in *cells*, each displayed *rectangle* or *cell* is basically either Markdown text (like this cell) or Python code. Python code can be *executed* by either clicking the  <span class=\"inline\">![](images/forwardicon.png)</span> in the 'Cell' menu in the menu bar or the key combination 'Shift-Enter'.\n",
    "\n",
    "<div class=\"my-notify-warning\">\n",
    "\n",
    "<p>**IMPORTANT for Execution. PLEASE READ**. At its simplest, this is a playbook and execution is top-down. Code cells will look something like `In [#]:` (with '#' being a number). That's where you want to single-click. To execute the code, simply hit Shift+Enter.</p>\n",
    "\n",
    "<p>The code should execute, and move onto the next cell. The number in `In [#]:` will change and if there is some return value (as opposed to an explicit `print()` statement) it will appear in an `Out [#]:` cell. The numbers will change after each cell execution.</p>\n",
    "\n",
    "<p>It's easy to \"execute\" an entire notebook, task-by-task, by continuing to execute Shift+Return. Also, if you ever see `In [*]:` in your code cells (note the asterisk '\\*'), it just means things are executing, and you are probably waiting on data to come back.</p>\n",
    "\n",
    "<p>So depending on what you're doing, some patience might be required.</p>\n",
    "\n",
    "</div>\n",
    "\n",
    "\n",
    "## Environment\n",
    "The workbench environment is running entirely inside of the provided MacBook Pros. We use [Vagrant](https://www.vagrantup.com/) to run two [CSR 1000V virtual routers](http://www.cisco.com/c/en/us/products/routers/cloud-services-router-1000v-series/index.html) running IOS XE 16.3.2 and we use [Docker](https://www.docker.com/) to provide the [Jupyter](http://jupyter.org/) interactive notebooks (like the document you are currently looking at).\n",
    "\n",
    "The Python environment in the notebooks communicate with the routers via a host-only *internal* network on the MacBook Pro. The MacBook has its own IP address on this host-only network: `172.20.20.1`. The container can access the routers on their own IP addresses, `172.20.20.10` and `172.20.20.20` respectively. The following diagram shows a high level overview of the environment:\n",
    "\n",
    "![Topology](images/topology.png)\n",
    "\n",
    "We can access the CLI of the CSR1000v using a terminal (`Terminal.app`) and, while in the Vagrant directory, typing `vagrant ssh rtr1` or `vagrant ssh rtr2`. Because a public key has been installed into the router(s), we get a privileged shell / CLI without being prompted for a password.\n",
    "\n",
    "While on the router, you can check the 'wsma' configuration section and also the remaining configuration which enables NETCONF and RESTCONF. \n",
    "\n",
    "Apart from a few static routes and an OSPF process there is not a lot else configured on the box."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Here we will set variables that we will use thoughout the session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "HOST = '172.20.20.10'\n",
    "PORT = 830\n",
    "USER = 'vagrant'\n",
    "PASS = 'vagrant'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Programmability has been around for a long time over the CLI API.  We all use it for FDN, but there are capabilities added over the years to communicate with devices via Python over ssh leveraging some form of python expect.  In this case we will use a tool called Netmiko.  However the format of the data is meant for human consumption, not a machine interface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import jtextfsm as textfsm\n",
    "from netmiko import ConnectHandler\n",
    "import pprint\n",
    "\n",
    "def get_show_inventory(ip, username, password, enable_secret):\n",
    "    # establish a connection to the device\n",
    "    ssh_connection = ConnectHandler(\n",
    "        device_type='cisco_ios',\n",
    "        ip=ip,\n",
    "        username=username,\n",
    "        password=password,\n",
    "        secret=enable_secret)\n",
    "    # enter enable mode\n",
    "    ssh_connection.enable()\n",
    "    # prepend the command prompt to the result (used to identify the local device)\n",
    "    result = ssh_connection.find_prompt() + \"\\n\"\n",
    "    # execute the show inventory command with extended delay\n",
    "    result += ssh_connection.send_command(\"show inventory\", delay_factor=2)\n",
    "    # close SSH connection\n",
    "    ssh_connection.disconnect()\n",
    "    return result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "If we are lucky there is some clear format of the response that we can leverage regular expression filters to turn the response into programming data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is what the text looks like\n",
      "rtr1#\n",
      "NAME: \"Chassis\", DESCR: \"Cisco CSR1000V Chassis\"\n",
      "PID: CSR1000V          , VID: V00  , SN: 9H79916HPTZ\n",
      "\n",
      "NAME: \"module R0\", DESCR: \"Cisco CSR1000V Route Processor\"\n",
      "PID: CSR1000V          , VID: V00  , SN: JAB1303001C\n",
      "\n",
      "NAME: \"module F0\", DESCR: \"Cisco CSR1000V Embedded Services Processor\"\n",
      "PID: CSR1000V          , VID:      , SN:            \n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "    raw_text_data = get_show_inventory(HOST, USER, PASS, PASS)\n",
    "    print ('This is what the text looks like\\n' + raw_text_data)\n",
    "    # Run the text through the FSM. \n",
    "    # The argument 'template' is a file handle and 'raw_text_data' is a \n",
    "    # string with the content from the show_inventory.txt file\n",
    "    template = open(\"/home/docker/cli/show_inventory_multiple.textfsm\")\n",
    "    re_table = textfsm.TextFSM(template)\n",
    "    fsm_results = re_table.ParseText(raw_text_data)\n",
    "    # build keys for inventory sub-items \n",
    "    keys = [s for s in re_table.header]\n",
    "    #build inventory list of dictionaries\n",
    "    inventory = []\n",
    "    for row in fsm_results:\n",
    "      entry = {}\n",
    "      for i, item in enumerate(row):\n",
    "        entry.update({keys[i]:item})\n",
    "      inventory.append(entry)\n",
    "    pp = pprint.PrettyPrinter(indent=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Here we can see what the template looks like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value Filldown hostname (\\S+)\n",
      "Value name (.+)\n",
      "Value description (.*)\n",
      "Value productid (\\S*)\n",
      "Value vid (\\S*)\n",
      "Value Required serialnumber (\\S+)\n",
      "\n",
      "Start\n",
      "  ^${hostname}[>#].*\n",
      "  ^NAME: \"${name}\", DESCR: \"${description}\"\n",
      "  ^PID: ${productid}.*VID: ${vid}.*SN: ${serialnumber} -> Record\n"
     ]
    }
   ],
   "source": [
    "    print(template.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now that we have srtuctured data, lets do something interesting with it.  We can choose how we display it or to even search for a value of interest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results translated through regular expression template organized as a dictonary\n",
      "[ { u'description': u'Cisco CSR1000V Chassis',\n",
      "    u'hostname': u'rtr1',\n",
      "    u'name': u'Chassis',\n",
      "    u'productid': u'CSR1000V',\n",
      "    u'serialnumber': u'9H79916HPTZ',\n",
      "    u'vid': u'V00'},\n",
      "  { u'description': u'Cisco CSR1000V Route Processor',\n",
      "    u'hostname': u'rtr1',\n",
      "    u'name': u'module R0',\n",
      "    u'productid': u'CSR1000V',\n",
      "    u'serialnumber': u'JAB1303001C',\n",
      "    u'vid': u'V00'}]\n",
      "[u'serialnumber', u'name', u'vid', u'description', u'hostname', u'productid']\n",
      "[u'9H79916HPTZ', u'Chassis', u'V00', u'Cisco CSR1000V Chassis', u'rtr1', u'CSR1000V']\n",
      "[u'JAB1303001C', u'module R0', u'V00', u'Cisco CSR1000V Route Processor', u'rtr1', u'CSR1000V']\n"
     ]
    }
   ],
   "source": [
    "    print('Results translated through regular expression template organized as a dictonary')\n",
    "    pp.pprint(inventory) # Print full inventory as dictionary\n",
    "    print([key for key, value in inventory[0].items()])  # print key values as list\n",
    "    for item in inventory:   # print inventory elements a table \n",
    "        print([item[key] for key in item])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Found Devices with specific productid devicex\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "    sought_product = 'devicex'\n",
    "    resultlist = [d for d in inventory if d.get('productid', '') == sought_product]\n",
    "    print('\\nFound Devices with specific productid ' + sought_product)\n",
    "    pp.pprint(resultlist) #print list of devices with sought productid\n",
    "    #print ([(item['hostname'], item['productid']) for item in resultlist])  #print found items as a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "However, we are not always so lucky to have data that we can easily parse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def get_show_ip_route(ip, username, password, enable_secret):\n",
    "    # establish a connection to the device\n",
    "    ssh_connection = ConnectHandler(\n",
    "        device_type='cisco_ios',\n",
    "        ip=ip,\n",
    "        username=username,\n",
    "        password=password,\n",
    "        secret=enable_secret)\n",
    "    # enter enable mode\n",
    "    ssh_connection.enable()\n",
    "    # prepend the command prompt to the result (used to identify the local device)\n",
    "    result = ssh_connection.find_prompt() + \"\\n\"\n",
    "    # execute the show inventory command with extended delay\n",
    "    result += ssh_connection.send_command(\"show ip route\", delay_factor=2)\n",
    "    # close SSH connection\n",
    "    ssh_connection.disconnect()\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is what the text looks like\n",
      "rtr1#\n",
      "Codes: L - local, C - connected, S - static, R - RIP, M - mobile, B - BGP\n",
      "       D - EIGRP, EX - EIGRP external, O - OSPF, IA - OSPF inter area \n",
      "       N1 - OSPF NSSA external type 1, N2 - OSPF NSSA external type 2\n",
      "       E1 - OSPF external type 1, E2 - OSPF external type 2\n",
      "       i - IS-IS, su - IS-IS summary, L1 - IS-IS level-1, L2 - IS-IS level-2\n",
      "       ia - IS-IS inter area, * - candidate default, U - per-user static route\n",
      "       o - ODR, P - periodic downloaded static route, H - NHRP, l - LISP\n",
      "       a - application route\n",
      "       + - replicated route, % - next hop override, p - overrides from PfR\n",
      "\n",
      "Gateway of last resort is 10.0.2.2 to network 0.0.0.0\n",
      "\n",
      "S*    0.0.0.0/0 [254/0] via 10.0.2.2\n",
      "      10.0.0.0/8 is variably subnetted, 2 subnets, 2 masks\n",
      "C        10.0.2.0/24 is directly connected, GigabitEthernet1\n",
      "L        10.0.2.15/32 is directly connected, GigabitEthernet1\n",
      "      172.16.0.0/16 is variably subnetted, 2 subnets, 2 masks\n",
      "C        172.16.100.0/24 is directly connected, GigabitEthernet3\n",
      "L        172.16.100.10/32 is directly connected, GigabitEthernet3\n",
      "      172.20.0.0/16 is variably subnetted, 2 subnets, 2 masks\n",
      "C        172.20.20.0/24 is directly connected, GigabitEthernet2\n",
      "L        172.20.20.10/32 is directly connected, GigabitEthernet2\n",
      "S     192.168.0.0/24 [1/0] via 172.20.20.100\n",
      "S     192.168.1.0/24 [1/0] via 172.20.20.100\n",
      "S     192.168.2.0/24 [1/0] via 172.20.20.100\n",
      "S     192.168.4.0/24 [1/0] via 172.20.20.100\n",
      "S     198.18.10.0/24 [1/0] via 172.20.20.100\n",
      "S     198.18.11.0/24 [1/0] via 172.20.20.100\n",
      "S     198.18.12.0/24 [1/0] via 172.20.20.100\n",
      "S     198.18.13.0/24 [1/0] via 172.20.20.100\n"
     ]
    }
   ],
   "source": [
    "raw_text_data = get_show_ip_route(HOST, USER, PASS, PASS)\n",
    "print ('This is what the text looks like\\n' + raw_text_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "So let's take a look at an aternative method of interacting with devices.  Let's consider the machine's needs and leverage a model built for it.  That brings us to NETCONF.  Let's try to grab the routing table via programmatic API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here we are printing the RIB as XML\n",
      "\n",
      "<?xml version=\"1.0\" ?>\n",
      "<rpc-reply message-id=\"urn:uuid:9cebf572-d260-4bfc-818e-c26930db577b\" xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" xmlns:nc=\"urn:ietf:params:xml:ns:netconf:base:1.0\">\n",
      " <data>\n",
      "  <routing-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-routing\">\n",
      "   <routing-instance>\n",
      "    <ribs>\n",
      "     <rib>\n",
      "      <name>ipv4-default</name>\n",
      "      <address-family>v4ur:ipv4-unicast</address-family>\n",
      "      <default-rib>true</default-rib>\n",
      "      <routes>\n",
      "       <route>\n",
      "        <destination-prefix>0.0.0.0/0</destination-prefix>\n",
      "        <route-preference>254</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>10.0.2.2</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>10.0.2.0/24</destination-prefix>\n",
      "        <route-preference>0</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <outgoing-interface>GigabitEthernet1</outgoing-interface>\n",
      "        </next-hop>\n",
      "        <source-protocol>direct</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>10.0.2.15/32</destination-prefix>\n",
      "        <route-preference>0</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <outgoing-interface>GigabitEthernet1</outgoing-interface>\n",
      "        </next-hop>\n",
      "        <source-protocol>direct</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>172.16.100.0/24</destination-prefix>\n",
      "        <route-preference>0</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <outgoing-interface>GigabitEthernet3</outgoing-interface>\n",
      "        </next-hop>\n",
      "        <source-protocol>direct</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>172.16.100.10/32</destination-prefix>\n",
      "        <route-preference>0</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <outgoing-interface>GigabitEthernet3</outgoing-interface>\n",
      "        </next-hop>\n",
      "        <source-protocol>direct</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>172.20.20.0/24</destination-prefix>\n",
      "        <route-preference>0</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <outgoing-interface>GigabitEthernet2</outgoing-interface>\n",
      "        </next-hop>\n",
      "        <source-protocol>direct</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>172.20.20.10/32</destination-prefix>\n",
      "        <route-preference>0</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <outgoing-interface>GigabitEthernet2</outgoing-interface>\n",
      "        </next-hop>\n",
      "        <source-protocol>direct</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>192.168.0.0/24</destination-prefix>\n",
      "        <route-preference>1</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>172.20.20.100</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>192.168.1.0/24</destination-prefix>\n",
      "        <route-preference>1</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>172.20.20.100</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>192.168.2.0/24</destination-prefix>\n",
      "        <route-preference>1</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>172.20.20.100</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>192.168.4.0/24</destination-prefix>\n",
      "        <route-preference>1</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>172.20.20.100</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>198.18.10.0/24</destination-prefix>\n",
      "        <route-preference>1</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>172.20.20.100</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>198.18.11.0/24</destination-prefix>\n",
      "        <route-preference>1</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>172.20.20.100</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>198.18.12.0/24</destination-prefix>\n",
      "        <route-preference>1</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>172.20.20.100</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "       <route>\n",
      "        <destination-prefix>198.18.13.0/24</destination-prefix>\n",
      "        <route-preference>1</route-preference>\n",
      "        <metric>0</metric>\n",
      "        <next-hop>\n",
      "         <next-hop-address>172.20.20.100</next-hop-address>\n",
      "        </next-hop>\n",
      "        <source-protocol>static</source-protocol>\n",
      "       </route>\n",
      "      </routes>\n",
      "     </rib>\n",
      "    </ribs>\n",
      "   </routing-instance>\n",
      "  </routing-state>\n",
      " </data>\n",
      "</rpc-reply>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import ncclient.manager\n",
    "import xml.dom.minidom\n",
    "from ncclient.operations import TimeoutExpiredError\n",
    "  \n",
    "route_filter = '''\n",
    "  <routing-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-routing\">\n",
    "    <routing-instance>\n",
    "      <ribs>\n",
    "        <rib>\n",
    "          <name>ipv4-default</name>\n",
    "          <address-family xmlns:v4ur=\"urn:ietf:params:xml:ns:yang:ietf-ipv4-unicast-routing\">v4ur:ipv4-unicast</address-family>\n",
    "          <default-rib>true</default-rib>\n",
    "          <routes/>\n",
    "        </rib>\n",
    "      </ribs>\n",
    "    </routing-instance>\n",
    "  </routing-state>\n",
    "  '''\n",
    "nckwargs = dict(\n",
    "    host=HOST,\n",
    "    port=PORT,\n",
    "    hostkey_verify=False,\n",
    "    username=USER,\n",
    "    password=PASS,\n",
    "    device_params={'name':\"csr\"}\n",
    ")\n",
    "m = ncclient.manager.connect(**nckwargs)  \n",
    "try:\n",
    "    print ('Here we are printing the RIB as XML\\n')\n",
    "    c = m.get(filter=('subtree', route_filter))\n",
    "    xmlDom = xml.dom.minidom.parseString(str(c))\n",
    "    print (xmlDom.toprettyxml( indent = \" \" ))\n",
    "except TimeoutExpiredError as e:\n",
    "    print(\"Operation timeout!\")\n",
    "except Exception as e:\n",
    "    print(\"ERORR severity={}, tag={}\".format(e.severity, e.tag))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now that is a lot of information to look through, maybe you are only interested in a few pieces of information per route.  We can apply an XPATH filter, which is to say we will parse the response programmatically and return the interesting data in a condensed format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Or we can just grab the information that is interesting\n",
      "\n",
      "[ { 'dest': '0.0.0.0/0', 'hop': '10.0.2.2', 'prot': 'static'},\n",
      "  { 'dest': '10.0.2.0/24', 'intfc': 'GigabitEthernet1', 'prot': 'direct'},\n",
      "  { 'dest': '10.0.2.15/32', 'intfc': 'GigabitEthernet1', 'prot': 'direct'},\n",
      "  { 'dest': '172.16.100.0/24', 'intfc': 'GigabitEthernet3', 'prot': 'direct'},\n",
      "  { 'dest': '172.16.100.10/32', 'intfc': 'GigabitEthernet3', 'prot': 'direct'},\n",
      "  { 'dest': '172.20.20.0/24', 'intfc': 'GigabitEthernet2', 'prot': 'direct'},\n",
      "  { 'dest': '172.20.20.10/32', 'intfc': 'GigabitEthernet2', 'prot': 'direct'},\n",
      "  { 'dest': '192.168.0.0/24', 'hop': '172.20.20.100', 'prot': 'static'},\n",
      "  { 'dest': '192.168.1.0/24', 'hop': '172.20.20.100', 'prot': 'static'},\n",
      "  { 'dest': '192.168.2.0/24', 'hop': '172.20.20.100', 'prot': 'static'},\n",
      "  { 'dest': '192.168.4.0/24', 'hop': '172.20.20.100', 'prot': 'static'},\n",
      "  { 'dest': '198.18.10.0/24', 'hop': '172.20.20.100', 'prot': 'static'},\n",
      "  { 'dest': '198.18.11.0/24', 'hop': '172.20.20.100', 'prot': 'static'},\n",
      "  { 'dest': '198.18.12.0/24', 'hop': '172.20.20.100', 'prot': 'static'},\n",
      "  { 'dest': '198.18.13.0/24', 'hop': '172.20.20.100', 'prot': 'static'}]\n"
     ]
    }
   ],
   "source": [
    "ns = 'urn:ietf:params:xml:ns:yang:ietf-routing'\n",
    "nsmap = dict(rt=ns)\n",
    "route_table=[]\n",
    "routes = c.data.findall(\".//{%s}route\" % ns)\n",
    "for i, route in enumerate(routes):\n",
    "    dest = route.xpath('./rt:destination-prefix/text()', namespaces=nsmap)\n",
    "    hop = route.xpath('./rt:next-hop/rt:next-hop-address/text()', namespaces=nsmap)\n",
    "    intfc = route.xpath('./rt:next-hop/rt:outgoing-interface/text()', namespaces=nsmap)\n",
    "    prot = route.xpath('./rt:source-protocol/text()', namespaces=nsmap)\n",
    "    if len(hop) > 0:\n",
    "        entry = {'hop':hop[0]}\n",
    "    if len(intfc) > 0:\n",
    "        entry = {'intfc':intfc[0]}  \n",
    "    entry.update({'dest':dest[0], 'prot':prot[0]}) \n",
    "    route_table.append(entry)\n",
    "print ('\\nOr we can just grab the information that is interesting\\n')\n",
    "pp = pprint.PrettyPrinter(indent=2)\n",
    "pp.pprint(route_table)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "That seems easier to work with, but what are the items we can request?  In this case we can look at the Model.\n",
    "There are to types of models, native (complete capability from the vendor) or the common models like ietf or openconfig."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " We are connecting to the device and downloading the YANG Module\n",
      "Now we will do a 'pyang -f tree of ietf-interfaces.yang'\n",
      "This structure is what data we can get (ro/rw) or set (rw)\n",
      "module: ietf-interfaces\n",
      "   +--rw interfaces\n",
      "   |  +--rw interface* [name]\n",
      "   |     +--rw name                        string\n",
      "   |     +--rw description?                string\n",
      "   |     +--rw type                        identityref\n",
      "   |     +--rw enabled?                    boolean\n",
      "   |     +--rw link-up-down-trap-enable?   enumeration {if-mib}?\n",
      "   +--ro interfaces-state\n",
      "      +--ro interface* [name]\n",
      "         +--ro name               string\n",
      "         +--ro type               identityref\n",
      "         +--ro admin-status       enumeration {if-mib}?\n",
      "         +--ro oper-status        enumeration\n",
      "         +--ro last-change?       yang:date-and-time\n",
      "         +--ro if-index           int32 {if-mib}?\n",
      "         +--ro phys-address?      yang:phys-address\n",
      "         +--ro higher-layer-if*   interface-state-ref\n",
      "         +--ro lower-layer-if*    interface-state-ref\n",
      "         +--ro speed?             yang:gauge64\n",
      "         +--ro statistics\n",
      "            +--ro discontinuity-time    yang:date-and-time\n",
      "            +--ro in-octets?            yang:counter64\n",
      "            +--ro in-unicast-pkts?      yang:counter64\n",
      "            +--ro in-broadcast-pkts?    yang:counter64\n",
      "            +--ro in-multicast-pkts?    yang:counter64\n",
      "            +--ro in-discards?          yang:counter32\n",
      "            +--ro in-errors?            yang:counter32\n",
      "            +--ro in-unknown-protos?    yang:counter32\n",
      "            +--ro out-octets?           yang:counter64\n",
      "            +--ro out-unicast-pkts?     yang:counter64\n",
      "            +--ro out-broadcast-pkts?   yang:counter64\n",
      "            +--ro out-multicast-pkts?   yang:counter64\n",
      "            +--ro out-discards?         yang:counter32\n",
      "            +--ro out-errors?           yang:counter32\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from subprocess import Popen, PIPE, STDOUT\n",
    "SCHEMA_TO_GET = 'ietf-interfaces'\n",
    "print(' We are connecting to the device and downloading the YANG Module')\n",
    "print(\"Now we will do a 'pyang -f tree of %s.yang'\" % SCHEMA_TO_GET)\n",
    "print('This structure is what data we can get (ro/rw) or set (rw)')\n",
    "c = m.get_schema(SCHEMA_TO_GET)\n",
    "p = Popen(['pyang', '-f', 'tree'], stdout=PIPE, stdin=PIPE, stderr=PIPE)\n",
    "stdout_data = p.communicate(input=c.data)[0]\n",
    "print stdout_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now that we know whats available, we can grab operational data for the device to give us some perspective of its state.  In the coming months this will instead be a telemetry stream that a client could register for vs a poll.  However, we can see the advantage of how we can manipulate the information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using NETCONF, you can present data as XML without any conversion\n",
      "<?xml version=\"1.0\" ?>\n",
      "<rpc-reply message-id=\"urn:uuid:932082be-6b01-496c-bfb9-68b6dd29368a\" xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" xmlns:nc=\"urn:ietf:params:xml:ns:netconf:base:1.0\">\n",
      " <data>\n",
      "  <cpu-usage xmlns=\"urn:cisco:params:xml:ns:yang:cisco-process-cpu\">\n",
      "   <cpu-utilization>\n",
      "    <five-seconds>0</five-seconds>\n",
      "    <five-seconds-intr>0</five-seconds-intr>\n",
      "    <one-minute>0</one-minute>\n",
      "    <five-minutes>0</five-minutes>\n",
      "   </cpu-utilization>\n",
      "  </cpu-usage>\n",
      " </data>\n",
      "</rpc-reply>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "cpu_util = '''<filter>\n",
    "<cpu-usage xmlns=\"urn:cisco:params:xml:ns:yang:cisco-process-cpu\">\n",
    "<cpu-utilization>\n",
    "</cpu-utilization>\n",
    "</cpu-usage></filter>'''\n",
    "\n",
    "cpu_process = '''<filter>\n",
    "<cpu-usage xmlns=\"urn:cisco:params:xml:ns:yang:cisco-process-cpu\" xmlns:y=\"http://tail-f.com/ns/rest\" xmlns:pcpu=\"urn:cisco:params:xml:ns:yang:cisco-process-cpu\">\n",
    "<process-cpu-usage>\n",
    "</process>\n",
    "</process-cpu-usage>\n",
    "</filter>'''\n",
    "print ('Using NETCONF, you can present data as XML without any conversion')\n",
    "cpu_util = str( m.get( filter=cpu_util ) )\n",
    "xmlDom = xml.dom.minidom.parseString(cpu_util)\n",
    "print xmlDom.toprettyxml( indent = \" \" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Or you can convert to Dictionary\n",
      "[(u'five-seconds', u'0'), (u'five-seconds-intr', u'0'), (u'one-minute', u'0'), (u'five-minutes', u'0')]\n"
     ]
    }
   ],
   "source": [
    "import xmltodict\n",
    "print ('Or you can convert to Dictionary')\n",
    "cpu_dict = xmltodict.parse( cpu_util )['rpc-reply']['data']\n",
    "print [(i,v) for i,v in cpu_dict['cpu-usage']['cpu-utilization'].iteritems()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "With structured data you can select data thats interesting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "With structured data you can filter or sort \n",
      "Here we are grabbing the processes with higher run-time\n",
      "(u'Load Meter', u'2', u'457')\n",
      "(u'MCP TIPC', u'3', u'392')\n",
      "(u'Check heaps', u'9', u'10706')\n",
      "(u'IPC Mcast Pendin', u'23', u'115')\n",
      "(u'GraphIt', u'53', u'122')\n",
      "(u'crypto sw pk pro', u'61', u'1046')\n",
      "(u'Net Background', u'69', u'641')\n",
      "(u'IOSD ipc task', u'76', u'2798')\n",
      "(u'PuntInject Keepa', u'83', u'416')\n",
      "(u'Environmental Mo', u'90', u'115')\n",
      "(u'DBAL EVENTS', u'93', u'360')\n",
      "(u'REDUNDANCY peer', u'95', u'118')\n",
      "(u'100ms check', u'96', u'1558')\n",
      "(u'IOSXE-RP Punt Se', u'118', u'252')\n",
      "(u'Per-minute Jobs', u'129', u'2284')\n",
      "(u'Per-Second Jobs', u'130', u'237')\n",
      "(u'ONEP Application', u'131', u'1510')\n",
      "(u'FPDB Timer Proce', u'134', u'210')\n",
      "(u'fanrp_l2fib', u'135', u'140')\n",
      "(u'DiagCard1/-1', u'178', u'470')\n",
      "(u'FHRP Main thread', u'183', u'122')\n",
      "(u'VRRS Main thread', u'187', u'1999')\n",
      "(u'IPAM Manager', u'196', u'3107')\n",
      "(u'IP ARP Retry Age', u'199', u'2988')\n",
      "(u'ONEP CLI Command', u'213', u'13694')\n",
      "(u'SSS Feature Time', u'220', u'556')\n",
      "(u'Tunnel BGP', u'228', u'1150')\n",
      "(u'Inspect process', u'351', u'202')\n",
      "(u'Timer Library', u'402', u'219')\n",
      "(u'MMA DB TIMER', u'407', u'2065')\n",
      "(u'TPS IPC Process', u'416', u'318')\n",
      "(u'Crypto IKEv2', u'428', u'133')\n",
      "(u'RSCMSM VOLUME MO', u'443', u'121')\n",
      "(u'DCM snmp dp Thre', u'484', u'235')\n",
      "(u'SBC main process', u'583', u'343')\n",
      "(u'ONEP Network Ele', u'595', u'1355')\n",
      "(u'OSPF-100 Router', u'608', u'152')\n"
     ]
    }
   ],
   "source": [
    "print ('\\nWith structured data you can filter or sort \\nHere we are grabbing the processes with higher run-time')\n",
    "cpu_dict = xmltodict.parse( str( m.get( filter=cpu_process ) ) )\n",
    "cpu_dict = cpu_dict['rpc-reply']['data']\n",
    "nonzero_process = [t for t in cpu_dict['cpu-usage']['process-cpu-usage']['process'] if int(t['total-run-time']) > 100]\n",
    "for i in nonzero_process: print (i['name'],i['pid'],i['total-run-time'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's take a look at the interface model and take a look at operational data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Here is the XML data for Interfaces Operational State\n",
      "<?xml version=\"1.0\" ?>\n",
      "<rpc-reply message-id=\"urn:uuid:01868d05-1608-4c64-8089-51398f05af3c\" xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" xmlns:nc=\"urn:ietf:params:xml:ns:netconf:base:1.0\">\n",
      " <data>\n",
      "  <interfaces-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-interfaces\">\n",
      "   <interface>\n",
      "    <statistics>\n",
      "     <in-octets>392250</in-octets>\n",
      "    </statistics>\n",
      "   </interface>\n",
      "   <interface>\n",
      "    <statistics>\n",
      "     <in-octets>1322447</in-octets>\n",
      "    </statistics>\n",
      "   </interface>\n",
      "   <interface>\n",
      "    <statistics>\n",
      "     <in-octets>0</in-octets>\n",
      "    </statistics>\n",
      "   </interface>\n",
      "   <interface>\n",
      "    <statistics>\n",
      "     <in-octets>0</in-octets>\n",
      "    </statistics>\n",
      "   </interface>\n",
      "   <interface>\n",
      "    <statistics>\n",
      "     <in-octets>0</in-octets>\n",
      "    </statistics>\n",
      "   </interface>\n",
      "  </interfaces-state>\n",
      " </data>\n",
      "</rpc-reply>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "CONF_FILTER ='''<filter>\n",
    "  <interfaces xmlns=\"urn:ietf:params:xml:ns:yang:ietf-interfaces\">\n",
    "    <interface></interface>\n",
    "  </interfaces>\n",
    "</filter>'''\n",
    "STATE_FILTER ='''<filter>\n",
    "  <interfaces-state xmlns=\"urn:ietf:params:xml:ns:yang:ietf-interfaces\">\n",
    "    <interface><statistics><in-octets></in-octets></statistics></interface>\n",
    "  </interfaces-state>\n",
    "</filter>'''\n",
    "print('\\nHere is the XML data for Interfaces Operational State')\n",
    "interfaces = m.get(STATE_FILTER)\n",
    "pp = pprint.PrettyPrinter(indent=2)\n",
    "print(xml.dom.minidom.parseString(interfaces.xml).toprettyxml(indent=\" \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "and configuration data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Here is the XML data for Interfaces Configuration\n",
      "<?xml version=\"1.0\" ?>\n",
      "<rpc-reply message-id=\"urn:uuid:4e8947a0-18ff-482e-a090-24a20b01a310\" xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" xmlns:nc=\"urn:ietf:params:xml:ns:netconf:base:1.0\">\n",
      " <data>\n",
      "  <interfaces xmlns=\"urn:ietf:params:xml:ns:yang:ietf-interfaces\">\n",
      "   <interface>\n",
      "    <name>GigabitEthernet1</name>\n",
      "    <type xmlns:ianaift=\"urn:ietf:params:xml:ns:yang:iana-if-type\">ianaift:ethernetCsmacd</type>\n",
      "    <enabled>true</enabled>\n",
      "    <ipv4 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\"/>\n",
      "    <ipv6 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\"/>\n",
      "   </interface>\n",
      "   <interface>\n",
      "    <name>GigabitEthernet2</name>\n",
      "    <type xmlns:ianaift=\"urn:ietf:params:xml:ns:yang:iana-if-type\">ianaift:ethernetCsmacd</type>\n",
      "    <enabled>true</enabled>\n",
      "    <ipv4 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\">\n",
      "     <address>\n",
      "      <ip>172.20.20.10</ip>\n",
      "      <netmask>255.255.255.0</netmask>\n",
      "     </address>\n",
      "    </ipv4>\n",
      "    <ipv6 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\"/>\n",
      "   </interface>\n",
      "   <interface>\n",
      "    <name>GigabitEthernet3</name>\n",
      "    <type xmlns:ianaift=\"urn:ietf:params:xml:ns:yang:iana-if-type\">ianaift:ethernetCsmacd</type>\n",
      "    <enabled>true</enabled>\n",
      "    <diffserv-target-entry xmlns=\"urn:ietf:params:xml:ns:yang:ietf-diffserv-target\">\n",
      "     <direction>outbound</direction>\n",
      "     <policy-name>POLICY-TRANSPORT-1-SHAPE-ONLY</policy-name>\n",
      "    </diffserv-target-entry>\n",
      "    <ipv4 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\">\n",
      "     <address>\n",
      "      <ip>172.16.100.10</ip>\n",
      "      <netmask>255.255.255.0</netmask>\n",
      "     </address>\n",
      "    </ipv4>\n",
      "    <ipv6 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\"/>\n",
      "   </interface>\n",
      "   <interface>\n",
      "    <name>Loopback999</name>\n",
      "    <type xmlns:ianaift=\"urn:ietf:params:xml:ns:yang:iana-if-type\">ianaift:softwareLoopback</type>\n",
      "    <enabled>true</enabled>\n",
      "    <ipv4 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\"/>\n",
      "    <ipv6 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\"/>\n",
      "   </interface>\n",
      "   <interface>\n",
      "    <name>Tunnel4</name>\n",
      "    <type xmlns:ianaift=\"urn:ietf:params:xml:ns:yang:iana-if-type\">ianaift:tunnel</type>\n",
      "    <enabled>true</enabled>\n",
      "    <ipv4 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\"/>\n",
      "    <ipv6 xmlns=\"urn:ietf:params:xml:ns:yang:ietf-ip\"/>\n",
      "   </interface>\n",
      "  </interfaces>\n",
      " </data>\n",
      "</rpc-reply>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "m = ncclient.manager.connect(**nckwargs)\n",
    "print('\\nHere is the XML data for Interfaces Configuration')\n",
    "interfaces = m.get_config('running',CONF_FILTER)\n",
    "print(xml.dom.minidom.parseString(interfaces.xml).toprettyxml(indent=\" \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now that we are all Python experts, let's take a different perspective.  Models are similar to Programming languages.  Containers are to Classes, Lists are to Lists, Leafs are to Objects or types.\n",
    "\n",
    "In a community effort we have \"compiled\" the YANG model in to Python code.  By importing a few libraries we can affect change on networking elements simply by manipulating code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GigabitEthernet1, ethernetCsmacd, None\n",
      "GigabitEthernet2, ethernetCsmacd, None\n",
      "GigabitEthernet3, ethernetCsmacd, None\n",
      "Loopback999, softwareLoopback, None\n",
      "Tunnel4, tunnel, None\n"
     ]
    }
   ],
   "source": [
    "from ydk.services import CRUDService\n",
    "from ydk.providers import NetconfServiceProvider\n",
    "from ydk.models.ietf import ietf_interfaces as intf\n",
    "from ydk.models.ietf import iana_if_type as iftype\n",
    "\n",
    "# create NETCONF provider\n",
    "provider = NetconfServiceProvider(address=HOST,\n",
    "                                  port=PORT,\n",
    "                                  username=USER,\n",
    "                                  password=PASS)\n",
    "\n",
    "# create CRUD service\n",
    "crud = CRUDService()\n",
    "\n",
    "# query object\n",
    "q_i = intf.Interfaces()\n",
    "\n",
    "# get stuff\n",
    "intfs = crud.read(provider, q_i)\n",
    "\n",
    "# print interface names and types\n",
    "for i in intfs.interface:\n",
    "    print('%s, %s, %s' % (i.name, i.type._meta_info().yang_name, i.description))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('GigabitEthernet1', 1916, 1000, <OperStatusEnum.up: 1>)\n",
      "('GigabitEthernet2', 5265, 1000, <OperStatusEnum.up: 1>)\n",
      "('GigabitEthernet3', 7728, 10000, <OperStatusEnum.up: 1>)\n",
      "('Loopback999', 0, 8000, <OperStatusEnum.up: 1>)\n",
      "('Tunnel4', 0, 0, <OperStatusEnum.down: 2>)\n"
     ]
    }
   ],
   "source": [
    "q_i = intf.InterfacesState()\n",
    "\n",
    "# get stuff\n",
    "intfs = crud.read(provider, q_i)\n",
    "q_i = intf.InterfacesState()\n",
    "\n",
    "# get stuff\n",
    "intfs = crud.read(provider, q_i)\n",
    "int_info=[(i.name, i.statistics.out_pkts, int(i.speed)/1000000, i.oper_status) for i in intfs.interface]\n",
    "for thing in int_info: print(str(thing))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Create Software Loopback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# new interface\n",
    "new_loopback = intf.Interfaces.Interface()\n",
    "\n",
    "# create a new loopback\n",
    "new_loopback.name = 'Loopback666'\n",
    "new_loopback.type = iftype.SoftwareloopbackIdentity()\n",
    "new_loopback.description = 'Created by DevNet2449'\n",
    "res = crud.create(provider, new_loopback)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GigabitEthernet1, ethernetCsmacd, None\n",
      "GigabitEthernet2, ethernetCsmacd, None\n",
      "GigabitEthernet3, ethernetCsmacd, None\n",
      "Loopback666, softwareLoopback, Created by DevNet2449\n",
      "Loopback999, softwareLoopback, None\n",
      "Tunnel4, tunnel, None\n"
     ]
    }
   ],
   "source": [
    "# get stuff\n",
    "q_i = intf.Interfaces()\n",
    "intfs = crud.read(provider, q_i)\n",
    "\n",
    "for i in intfs.interface:\n",
    "    print('%s, %s, %s' % (i.name, i.type._meta_info().yang_name, i.description))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Delete Software Loopback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# create CRUD service\n",
    "crud = CRUDService()\n",
    "\n",
    "# interface to delete\n",
    "to_del = intf.Interfaces.Interface()\n",
    "\n",
    "# create a new loopback\n",
    "to_del.name = 'Loopback666'\n",
    "res = crud.delete(provider, to_del)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GigabitEthernet1, ethernetCsmacd, None\n",
      "GigabitEthernet2, ethernetCsmacd, None\n",
      "GigabitEthernet3, ethernetCsmacd, None\n",
      "Loopback999, softwareLoopback, None\n",
      "Tunnel4, tunnel, None\n"
     ]
    }
   ],
   "source": [
    "# get stuff\n",
    "intfs = crud.read(provider, q_i)\n",
    "\n",
    "for i in intfs.interface:\n",
    "    print('%s, %s, %s' % (i.name, i.type._meta_info().yang_name, i.description))\n",
    "provider.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}