workshop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understand NETCONF/YANG and build your first NETCONF client with Python to interwork with IOS-XR\n",
    "\n",
    "This laboratory addresses the functionality of IOS XR to communicate over the Network Configuration Protocol (NETCONF). This functionality benefits the remote configuration of IOS XR devices through configuration managers that act as NETCONF clients.\n",
    "\n",
    "The current infrastructure of IOS XR benefits the demand for network automation of increasingly bigger networks. The infrastructure offers flexibility in the range of management protocols, as well as in encoding formats. The wide featureset of YANG models includes native, OpenConfig and IETF models and allows a programmable interaction with such network devices. Lastly, the decoupling of these three components within the infrastructure show its adaptability to preferences for networking and programming tools.\n",
    "\n",
    "<img src=\"images/configuration management.png\">\n",
    "\n",
    "<mark>NOTE</mark>\n",
    "\n",
    "References on the NETCONF protocol:\n",
    " - [Network Configuration Protocol (NETCONF) - RFC 6241](https://tools.ietf.org/html/rfc6241)\n",
    " - [NETCONF Event Notifications - RFC 5277](https://tools.ietf.org/html/rfc5277)\n",
    "\n",
    "References on NETCONF-based programmability on IOS XR:\n",
    "\n",
    "\n",
    " ASR 9000\n",
    "  - [Programmability Configuration Guide](https://www.cisco.com/c/en/us/td/docs/routers/asr9000/software/asr9k-r7-0/programmability/configuration/guide/b-programmability-cg-asr9000-70x/b-programmability-cg-asr9000-70x_chapter_010.html)\n",
    "  - [Yang Data Models](https://www.cisco.com/c/en/us/td/docs/routers/asr9000/software/asr9k-r7-0/programmability/configuration/guide/b-programmability-cg-asr9000-70x/b-programmability-cg-asr9000-70x_chapter_01.html)\n",
    "  - [Telemetry Configuration](https://www.cisco.com/c/en/us/td/docs/routers/asr9000/software/asr9k-r7-0/telemetry/configuration/guide/b-telemetry-cg-asr9000-70x.html)\n",
    "\n",
    "\n",
    "\n",
    " NCS 5000\n",
    "  - [Programmability Configuration Guide](https://www.cisco.com/c/en/us/td/docs/iosxr/ncs5000/programmability/70x/b-programmability-cg-ncs5000-70x/b-programmability-cg-ncs5000-70x_chapter_010.html)\n",
    "  - [YANG Data Models](https://www.cisco.com/c/en/us/td/docs/iosxr/ncs5000/programmability/70x/b-programmability-cg-ncs5000-70x/b-programmability-cg-ncs5000-70x_chapter_01.html)\n",
    "  - [Telemetry Configuration](cisco.com/c/en/us/td/docs/iosxr/ncs5000/programmability/70x/b-programmability-cg-ncs5000-70x.html)\n",
    "\n",
    "**NETCONF overview**\n",
    "\n",
    "NETCONF is a communication protocol for network management, used over Secure Shell (SSH) transport. Network devices will typically run NETCONF servers and a NETCONF client / application will use Remote Procedure Calls (RPCs) to retrieve the state of a device or to modify a device's configuration. A NETCONF operation and its payload are encoded in the Extensible Markup Format (XML).\n",
    "\n",
    "IOS XR comes with a NETCONF server that can be activated using the following commands:\n",
    " ```\n",
    " netconf-yang agent ssh\n",
    " netconf agent tty\n",
    " \n",
    " ssh server v2\n",
    " ssh server netconf vrf default\n",
    " ```\n",
    " \n",
    " By default, the server will open port 830 for NETCONF communication.\n",
    " \n",
    " **Configuration datastores in NETCONF**\n",
    " \n",
    " A NETCONF server will have defined one or more configuration datastores available for configuration management. Such a datastore contains configuration needed to transition the device from an initial state to the intended operational state. The `<running>` configuration datastore holds the current active configuration on the device and is present in the base implementation of the protocol. Support for more datastores can be defined by extending the capabilities of a device.\n",
    " \n",
    " In the case of IOS XR, there are two datastores available:\n",
    " - `<running>` - it holds the active configuration of the device\n",
    " - `<candidate>` - it holds configuration that can be changed without affecting the running configuration; the changes can be committed to the running configuration datastore or they can be discarded\n",
    " \n",
    " \n",
    " **Protocol operations in NETCONF**\n",
    " \n",
    "NETCONF supports operations for configuration management and state retrieval. The operations from the base protocol are:\n",
    "- **`get`** - the client requests a copy of the running configuration and of the device's state \n",
    "- **`get-config`** - the client requests a copy of the configuration of a datastore; filters are supported\n",
    "- **`edit-config`** - the client asks the server to apply modifications to the configuration of a target datastore\n",
    "- `copy-config` - the client asks the server to create or overwrite the entire target configuration datastore with the contents of another datastore\n",
    "- `delete-config` - the client asks the server to delete the target configuration datastore\n",
    "- **`lock`** - the client locks a server's target configuration datastore; this is intended for short time periods when changes are being applied and interference with other clients or management entities is unwanted \n",
    "- **`unlock`** - the client releases the lock from a server's target configuration datastore\n",
    "- **`close-session`** - the client gracefully ends its NETCONF session with the server\n",
    "- `kill-session` - the client forcely ends its NETCONF session with the server, aborting ongoing operations\n",
    "\n",
    "In this laboratory you will practice the operations highlighted in bold."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Connect over NETCONF to the IOS XR device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <mark>TASK 1</mark>\n",
    " \n",
    " Load parameters for the connection with the IOS XR device:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import configparser\n",
    "config = configparser.ConfigParser()\n",
    "config.read('workshop-configuration.ini')\n",
    "device=config['DEVICE']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " In this laboratory we will use the `ncclient` library that is a Python implementation of functionalities for a NETCONF client.\n",
    " \n",
    " <mark>NOTE</mark> - For more information about the `ncclient` see:\n",
    " - https://github.com/ncclient/ncclient\n",
    " - https://developer.cisco.com/codeexchange/github/repo/ncclient/ncclient/\n",
    " \n",
    " \n",
    " <mark>TASK 2</mark>\n",
    " \n",
    " Connect to the IOS XR device:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ncclient import manager\n",
    "\n",
    "netconf_connection = manager.connect(host=device['Host'], \n",
    "                                     port=device['NCPort'],\n",
    "                                     username=device['UserName'],\n",
    "                                     password=device['Password'],\n",
    "                                     hostkey_verify=False,\n",
    "                                     device_params={'name':'iosxr'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieval of the capabilities advertised by the IOS XR device\n",
    "\n",
    "During the session establishment, both the client and the server will verify that they have a common protocol version. Additionally, they will exchange the capabilities that are supported.\n",
    "\n",
    " <mark>TASK 3</mark>\n",
    " \n",
    " Retrieve the capabilities of IOS XR. Notice the first 7 capabilities with URI of the form `urn:ietf:params:netconf:...` - these are capabilities implemented as per the RFC 6241 and RFC 5277. The rest of the capabilities represent YANG data models and are explained in the next section of this laboratory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for capability in netconf_connection.server_capabilities:\n",
    "    print (capability)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model-driven programmability\n",
    "\n",
    "#### YANG - A Data Modelling Language\n",
    "\n",
    "A data model is written in YANG data modelling language and is used for describing configuration data and operational states in a hierarchical manner. YANG data models are defined in highly structured text files and are compilabl. YANG's statically-typed syntax and semantic definition ensures the verification of the model's definition at compile time, resulting in errors that can be treated early in the development process.\n",
    "\n",
    "YANG data models can be instantiated with an XML definition. This type of instantiation is powerful and binds the purpose of NETCONF to the abstractization of the device management: one can now configure the device over NETCONF, using XML instantiations of all the supported data models advertised by the device. This allows for automatization of network management operations, replacing the command line configuration that is prone to human error, with a programming-friendly structure.\n",
    " \n",
    " <mark>NOTE</mark> - Reference on YANG:\n",
    " - [RFC 6020 - YANG - A Data Modeling Language for the Network Configuration Protocol (NETCONF)](https://tools.ietf.org/html/rfc6020)\n",
    " - [The YANG 1.1 Data Modeling Language - RFC 7950](https://tools.ietf.org/html/rfc7950)\n",
    " \n",
    " \n",
    " Throughout the rest of this laboratory we will explore the NETCONF operations for automated configuration of the IOS XR device and monitor the data rate of generated traffic. The configuration and data streaming will be based on YANG models, i.e., model-driven:\n",
    " \n",
    "<img src=\"images/model-driven programmability.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieval of the configuration for model-driven telemetry streaming (dial-out)\n",
    "\n",
    "The IOS XR device has been preconfigured for model-driven telemetry (MDT) streaming using the gRPC dial-out mechanism.\n",
    "\n",
    "In this case, the device initiates a gRPC session (dial-out) with the MDT receiver (i.e., the host that runs the Jupyter notebook - 198.18.134.50) and exchanges SYN -- SYN-ACK -- ACK with it while establishing the connection.\n",
    "\n",
    "If the connection is successfully created, the device will start streaming telemetry data towards the collection point.\n",
    "\n",
    "The configuration consists of:\n",
    "\n",
    "- A **sensor-group** that is composed of sensor-path(s):\n",
    "  - A **sensor-path** is a specification of the YANG component about which information should be streamed. It is specified in XPath format\n",
    "- A **destination-group** that is composed of destination(s):\n",
    "  - A **destination** contains the receiver's specifications:\n",
    "    - IP address\n",
    "    - port\n",
    "    - encoding format\n",
    "    - protocol\n",
    "- A **subscription** that brings together a sensor-group, a destination-group and a time interval [ms]\n",
    "\n",
    "In this case, we subscribe to real-time updates of the operational state of all interfaces (`Cisco-IOS-XR-ifmgr-oper`). We expect to receive data regularly, every 10 seconds.\n",
    "\n",
    "<mark>TASK 4</mark>\n",
    "\n",
    "Define a data filter for the NETCONF RPC request. This filter is written in XML format and is used to restrict the retrieval of running-configuration: here, we ask only for the model-driven telemetry configuration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_payload = \"\"\"\n",
    "<filter>\n",
    " <telemetry-model-driven xmlns=\"http://cisco.com/ns/yang/Cisco-IOS-XR-telemetry-model-driven-cfg\">\n",
    " </telemetry-model-driven>\n",
    "</filter>\n",
    "\"\"\"\n",
    "netconf_connection.get_config(source='running', filter=filter_payload)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>NOTE</mark> - Observe the content of `<data>` from the `<rpc-reply>`. This is an example of an instantiation of the YANG data model `Cisco-IOS-XR-telemetry-model-driven-cfg`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieval of the operational state of model-driven telemetry streaming\n",
    "\n",
    "Check that MDT streaming is in an active state. Notice that several collections have been made so far:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_payload = \"\"\"\n",
    "<filter>\n",
    " <telemetry-model-driven xmlns=\"http://cisco.com/ns/yang/Cisco-IOS-XR-telemetry-model-driven-oper\">\n",
    " </telemetry-model-driven>\n",
    "</filter>\n",
    "\"\"\"\n",
    "netconf_connection.get(filter=filter_payload)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monitoring the streamed model-driven telemetry data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The host 198.18.134.50 already has the collection components for ingesting, storing and visualizing telemetry data. We are using the following set of Docker containers:\n",
    "- Telegraf - a collection container that runs the cisco_telemetry_mdt plugin for ingestion of model-driven telemetry data\n",
    "- InfluxDB - a storage container that runs a database which stores the data\n",
    "- Chronograf - a visualization container that runs a web application which allows the exploration of data\n",
    "\n",
    "The collector has been configured to listen on port `57777` for incoming connections. IOS XR will initiate the connection, dialling out to the collector. After the connection establishment, the device will begin to stream data to the collector which will send it to a database named `telemetry`.\n",
    "\n",
    " <mark>NOTE</mark> - Please refer to the following references for details about the three components and the ingestion of telemetry data:\n",
    " - [InfluxData](https://www.influxdata.com/)\n",
    " - [Input plugin for Model-driven telemetry](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/cisco_telemetry_mdt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 5</mark>\n",
    "\n",
    "In a separate browser tab, open the web application for data visualization located at http://198.18.134.50:8888. Then, hover over the left hand-side and click on `Dashboards`. Open the `Traffic Monitoring` dashboard.\n",
    "\n",
    "<mark>NOTE</mark> - If you are missing the dashboard, use the `Import Dashboard` button to upload the dashboard located at `monitoring/chronograf/Traffic Monitoring.json`.\n",
    "\n",
    "\n",
    "We intend to monitor the input and output data rate for the `GigabitEthernet0/0/0/0`. Currently, there is no data about its traffic.\n",
    "\n",
    "Notice that we are also monitoring the state of two interfaces, and receiving data in real-time:\n",
    "- `GigabitEthernet0/0/0/0` - up\n",
    "- `Loopback0` - down\n",
    "\n",
    "<img src=\"images/traffic 0.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuration modification for model-driven telemetry streaming\n",
    "\n",
    "In this section you will add a new sensor-path to the active telemetry subscription. This should send statistics of the interfaces of IOS XR. Use the following sensor-group and sensor-path:\n",
    "\n",
    "- sensor-group: `SGroupGeneric1`\n",
    "  - sensor-path: `Cisco-IOS-XR-infra-statsd-oper:infra-statistics/interfaces/interface/latest/generic-counters`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 6</mark>\n",
    "\n",
    "`Lock` the `candidate` datastore of the device. This prevents another entity or NETCONF session from making modifications to the datastore. The lock lasts until the `unlock` RPC is sent or until the NETCONF session closes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.lock('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 7</mark>\n",
    "\n",
    "Define the configuration for model-driven telemetry. The configuration is in XML format, hierarchically structured, as defined by the YANG data model `Cisco-IOS-XR-telemetry-model-driven-cfg`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = \"\"\"\n",
    "<config>\n",
    "\n",
    "  <telemetry-model-driven xmlns=\"http://cisco.com/ns/yang/Cisco-IOS-XR-telemetry-model-driven-cfg\">\n",
    "\n",
    "   <sensor-groups>\n",
    "    <sensor-group>\n",
    "     <sensor-group-identifier>SGroupGeneric1</sensor-group-identifier>\n",
    "\n",
    "     <sensor-paths>\n",
    "      <sensor-path>\n",
    "       <telemetry-sensor-path>Cisco-IOS-XR-infra-statsd-oper:infra-statistics/interfaces/interface/latest/generic-counters</telemetry-sensor-path>\n",
    "      </sensor-path>\n",
    "     </sensor-paths>\n",
    "\n",
    "    </sensor-group>\n",
    "   </sensor-groups>\n",
    "\n",
    "  </telemetry-model-driven>\n",
    "\n",
    "</config>\n",
    "\"\"\"\n",
    "\n",
    "netconf_connection.edit_config(target='candidate', config=config, default_operation='merge')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 8</mark>\n",
    "\n",
    "Check that the configuration is syntactically and semantically correct:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.validate('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 9</mark>\n",
    "\n",
    "Commit the changes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.commit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 10</mark>\n",
    "\n",
    "Finally, unlock the `candidate` datastore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.unlock('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 11</mark>\n",
    "\n",
    "Open the `Traffic Monitoring` dashboard (http://198.18.134.50:8888/sources/0/dashboards/1?lower=now()-5m).\n",
    "\n",
    "Roughly 10 seconds after the configuration, the receiver will be actively monitoring the input and output data rate for the `GigabitEthernet0/0/0/0`. Currently, there is little traffic, with approximately 1 Kbits/sec input and 7 Kbits/sec output rate.\n",
    "\n",
    "<img src=\"images/traffic 1.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traffic generation\n",
    "\n",
    "The IOS XR hosts an Iperf server for traffic generation. An Iperf client will contact the server and start sending and receiving information at a 1 Mbits/sec rate. In order to send and receive traffic the following steps are required:\n",
    "\n",
    "**1. Bring up the Loopback 0**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 12</mark>\n",
    "\n",
    "Lock the `candidate` datastore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.lock('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 13</mark>\n",
    "\n",
    "Bring up the `Loopback0` by submitting to the `candidate` datastore a configuration change equivalent to the CLI command `no shutdown`:\n",
    "\n",
    "```\n",
    "[...]\n",
    "     <shutdown xc:operation=\"delete\"></shutdown>\n",
    "[...]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = \"\"\"\n",
    "<config xmlns:xc=\"urn:ietf:params:xml:ns:netconf:base:1.0\">\n",
    "  <interface-configurations xmlns=\"http://cisco.com/ns/yang/Cisco-IOS-XR-ifmgr-cfg\">\n",
    "   <interface-configuration>\n",
    "\n",
    "    <active>act</active>\n",
    "    <interface-name>Loopback0</interface-name>\n",
    "    \n",
    "    <shutdown xc:operation=\"delete\"></shutdown>\n",
    "    \n",
    "   </interface-configuration>\n",
    "  </interface-configurations>\n",
    "</config>\n",
    "\"\"\"\n",
    "\n",
    "netconf_connection.edit_config(target='candidate', config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 14</mark>\n",
    "\n",
    "Validate the modification of the configuration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.validate('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 15</mark>\n",
    "\n",
    "Commit this change to the `running` datastore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.commit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 16</mark>\n",
    "\n",
    "Unlock the `candidate` datastore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.unlock('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Start the Iperf server on the IOS XR device**\n",
    "\n",
    "<mark>TASK 17</mark>\n",
    "\n",
    "Connect to the IOS XR's CLI over SSH and start the Iperf server\n",
    "```\n",
    "$ ssh cisco@198.18.134.72\n",
    "\n",
    "RP/0/RP0/CPU0:IOSXR# bash -c iperf -sD\n",
    "[...]\n",
    "Running Iperf Server as a daemon\n",
    "The Iperf daemon process ID : 1266\n",
    "\n",
    "```\n",
    "\n",
    "By default, the server will listen on port `5001` for incoming connections."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Start the Iperf client on the VM**\n",
    "\n",
    "<mark>TASK 18</mark>\n",
    "\n",
    "Connect to the VM over SSH and start the Iperf client. The client will connect to the host `1.1.1.1` and ask for a bandwidth rate for send and receive of `1000000 bits/sec` (`1 Mbits/sec`).\n",
    "\n",
    "```\n",
    "$ ssh cisco@198.18.134.50\n",
    "\n",
    "[cisco@centos ~]$ iperf -c 1.1.1.1 -b 1000000 -d -t 3600 -i 10\n",
    "------------------------------------------------------------\n",
    "Server listening on TCP port 5001\n",
    "TCP window size: 85.3 KByte (default)\n",
    "------------------------------------------------------------\n",
    "------------------------------------------------------------\n",
    "Client connecting to 1.1.1.1, TCP port 5001\n",
    "TCP window size: 45.0 KByte (default)\n",
    "------------------------------------------------------------\n",
    "[  5] local 198.18.134.50 port 5001 connected with 1.1.1.1 port 64883\n",
    "recvack failed: Resource temporarily unavailable\n",
    "[  4] local 198.18.134.50 port 54318 connected with 1.1.1.1 port 5001 (server version is old)\n",
    "[ ID] Interval       Transfer     Bandwidth\n",
    "[  5]  0.0-10.0 sec  1.19 MBytes  1.00 Mbits/sec\n",
    "[  4]  0.0-10.0 sec  1.12 MBytes   944 Kbits/sec\n",
    "[...]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Real-time monitoring of the generated traffic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 19</mark>\n",
    "\n",
    "Return to the `Traffic Monitoring` dashboard (http://198.18.134.50:8888/sources/0/dashboards/1?lower=now()-5m) and confirm the following:\n",
    "\n",
    "- `Loopback0` is up\n",
    "- The input and output rates of IOS-XR's `GigabitEthernet0/0/0/0` interface grew to approximately 1 Mbits/sec\n",
    "\n",
    "<img src=\"images/traffic 2.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying configuration with confirmed-commit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As seen in the advertised capabilities, IOS-XR supports the `confirmed-commit` capability. This ensures that the changes that are to be committed will be reverted in case a timeout expires without receiving a confirming commit.\n",
    "\n",
    "This feature is useful in scenarios when the changes have been submitted to the device but the session has closed prematurely, resulting in an inconsistency between the changes expected by the NETCONF client and the state of the device. By providing a timeout interval and requesting a confirmation, the NETCONF client asks the IOS XR device to expect its acknowledgement of applied changes before making them persistent.\n",
    "\n",
    "To exercise this feature, perform a confirmed-commit that will timeout in 60 seconds:\n",
    "\n",
    "<mark>TASK 20</mark>\n",
    "\n",
    "Lock the `candidate` datastore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.lock('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 21</mark>\n",
    "\n",
    "Shutdown the `Loopback0`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = \"\"\"\n",
    "<config xmlns:xc=\"urn:ietf:params:xml:ns:netconf:base:1.0\">\n",
    "  <interface-configurations xmlns=\"http://cisco.com/ns/yang/Cisco-IOS-XR-ifmgr-cfg\">\n",
    "   <interface-configuration>\n",
    "\n",
    "    <active>act</active>\n",
    "    <interface-name>Loopback0</interface-name>\n",
    "    \n",
    "    <shutdown></shutdown>\n",
    "    \n",
    "   </interface-configuration>\n",
    "  </interface-configurations>\n",
    "</config>\n",
    "\"\"\"\n",
    "\n",
    "netconf_connection.edit_config(target='candidate', config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 22</mark>\n",
    "\n",
    "Validate the shutdown configuration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.validate('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 23</mark>\n",
    "\n",
    "Submit the changes from the `candidate` to the `running` datastore but mention that this is a confirmed commit that times out in 60 seconds:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.commit(confirmed=True, timeout=u'60')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 24</mark>\n",
    "\n",
    "Go back to the `Traffic Monitoring` dashboard. Notice that the device stops receiving traffic once the `Loopback0` is shutdown:\n",
    "\n",
    "<img src=\"images/traffic 3.png\">\n",
    "\n",
    "Because this was a commit requesting to be followed by a confirming commit, after approximately 70 seconds, the `Loopback0` reverts its shutdown and comes back up:\n",
    "\n",
    "<img src=\"images/traffic 4.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 25</mark>\n",
    "\n",
    "Unlock the `candidate` datastore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.unlock('candidate')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<mark>TASK 26</mark>\n",
    "\n",
    "Finally, end this laboratory by closing your NETCONF session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netconf_connection.close_session()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}