🎓 DevNet Resources & Programmability

// YANG Model Example (simplified)
module ietf-interfaces {
    namespace "urn:ietf:params:xml:ns:yang:ietf-interfaces";
    prefix if;
    
    container interfaces {
        list interface {
            key "name";
            
            leaf name {
                type string;
                description "Interface name";
            }
            
            leaf description {
                type string;
                description "Interface description";
            }
            
            leaf enabled {
                type boolean;
                default true;
                description "Interface admin status";
            }
            
            leaf type {
                type identityref {
                    base interface-type;
                }
                description "Interface type";
            }
        }
    }
}

#!/usr/bin/env python3
"""
NETCONF Complete Example
Demonstrates all major operations
"""

from ncclient import manager
import xml.dom.minidom

# Connect to device
def netconf_connect(host, username, password):
    """Establish NETCONF session"""
    device = {
        'host': host,
        'port': 830,
        'username': username,
        'password': password,
        'hostkey_verify': False,
        'device_params': {'name': 'iosxe'}
    }
    
    conn = manager.connect(**device)
    print(f"✅ NETCONF connected to {host}")
    return conn

# Get capabilities
def get_capabilities(conn):
    """List device YANG capabilities"""
    print("\n" + "="*70)
    print("DEVICE CAPABILITIES")
    print("="*70)
    
    for capability in conn.server_capabilities:
        if 'ietf-interfaces' in capability:
            print(f"✅ {capability}")

# Get configuration
def get_running_config(conn):
    """Get running configuration"""
    config = conn.get_config(source='running')
    
    # Pretty print XML
    xml_str = xml.dom.minidom.parseString(str(config)).toprettyxml()
    print("\n✅ Running configuration retrieved")
    return config

# Get interface using filter
def get_interface_config(conn, interface_name):
    """Get specific interface configuration"""
    
    filter_xml = f"""
    
        
            
                {interface_name}
            
        
    
    """
    
    result = conn.get(filter=filter_xml)
    print(f"\n✅ Retrieved {interface_name} configuration")
    return result

# Configure interface
def configure_interface(conn, intf_name, description, enabled=True):
    """Configure interface using edit-config"""
    
    config_xml = f"""
    
        
            
                {intf_name}
                {description}
                {str(enabled).lower()}
            
        
    
    """
    
    # Edit configuration
    response = conn.edit_config(
        target='running',
        config=config_xml
    )
    
    print(f"✅ Interface {intf_name} configured via NETCONF")
    return response

# Use candidate configuration (safer)
def configure_with_candidate(conn, config_xml):
    """Use candidate datastore with validation"""
    
    # Lock candidate config
    conn.lock(target='candidate')
    print("🔒 Candidate config locked")
    
    try:
        # Edit candidate
        conn.edit_config(target='candidate', config=config_xml)
        print("✅ Changes staged in candidate")
        
        # Validate
        conn.validate(source='candidate')
        print("✅ Configuration validated")
        
        # Commit to running
        conn.commit()
        print("✅ Configuration committed to running")
        
    except Exception as e:
        print(f"❌ Error: {e}")
        # Discard changes
        conn.discard_changes()
        print("⚠️  Changes discarded")
    
    finally:
        # Unlock
        conn.unlock(target='candidate')
        print("🔓 Candidate config unlocked")

# Main execution
if __name__ == "__main__":
    conn = netconf_connect('ios-xe.example.com', 'admin', 'cisco')
    
    # Get capabilities
    get_capabilities(conn)
    
    # Configure interface
    configure_interface(
        conn,
        'GigabitEthernet1',
        'Configured via NETCONF',
        enabled=True
    )
    
    # Close session
    conn.close_session()
    print("\n✅ NETCONF session closed")

# RESTCONF URL Format
https://{device}/restconf/data/{yang-module}:{container}/{list-entry}

# Examples:

# Get all interfaces
GET https://ios-xe/restconf/data/ietf-interfaces:interfaces

# Get specific interface
GET https://ios-xe/restconf/data/ietf-interfaces:interfaces/interface=GigabitEthernet1

# Get IP configuration
GET https://ios-xe/restconf/data/ietf-interfaces:interfaces/interface=GigabitEthernet1/ietf-ip:ipv4

# Configure interface (PATCH)
PATCH https://ios-xe/restconf/data/ietf-interfaces:interfaces/interface=GigabitEthernet1
Body: {"ietf-interfaces:interface": {"description": "Updated via RESTCONF"}}

# Create new configuration (POST)
POST https://ios-xe/restconf/data/ietf-interfaces:interfaces
Body: {"ietf-interfaces:interface": {"name": "Loopback100", "type": "softwareLoopback"}}

# Delete configuration (DELETE)
DELETE https://ios-xe/restconf/data/ietf-interfaces:interfaces/interface=Loopback100

#!/usr/bin/env python3
"""
RESTCONF Complete Example
Demonstrates CRUD operations on IOS XE
"""

import requests
import json
from requests.auth import HTTPBasicAuth
import urllib3
urllib3.disable_warnings()

class RESTCONFClient:
    """RESTCONF API Client for IOS XE"""
    
    def __init__(self, host, username, password):
        self.base_url = f"https://{host}/restconf/data"
        self.auth = HTTPBasicAuth(username, password)
        self.headers = {
            'Accept': 'application/yang-data+json',
            'Content-Type': 'application/yang-data+json'
        }
    
    def get_interfaces(self):
        """GET - Retrieve all interfaces"""
        url = f"{self.base_url}/ietf-interfaces:interfaces"
        
        response = requests.get(
            url,
            auth=self.auth,
            headers=self.headers,
            verify=False
        )
        
        if response.status_code == 200:
            data = response.json()
            interfaces = data['ietf-interfaces:interfaces']['interface']
            
            print("="*70)
            print("INTERFACES")
            print("="*70)
            
            for intf in interfaces:
                print(f"\n{intf['name']}")
                print(f"  Type: {intf['type']}")
                print(f"  Enabled: {intf.get('enabled', 'N/A')}")
                print(f"  Description: {intf.get('description', 'None')}")
            
            return interfaces
        else:
            print(f"❌ Error: {response.status_code}")
            return []
    
    def get_interface(self, name):
        """GET - Retrieve specific interface"""
        url = f"{self.base_url}/ietf-interfaces:interfaces/interface={name}"
        
        response = requests.get(
            url,
            auth=self.auth,
            headers=self.headers,
            verify=False
        )
        
        if response.status_code == 200:
            intf = response.json()['ietf-interfaces:interface']
            print(f"\n✅ Interface {name}:")
            print(f"   Type: {intf['type']}")
            print(f"   Admin Status: {'Up' if intf.get('enabled', False) else 'Down'}")
            return intf
        return None
    
    def create_loopback(self, number, description, ip_address, subnet_mask):
        """POST - Create new loopback interface"""
        url = f"{self.base_url}/ietf-interfaces:interfaces"
        
        data = {
            "ietf-interfaces:interface": {
                "name": f"Loopback{number}",
                "description": description,
                "type": "iana-if-type:softwareLoopback",
                "enabled": True,
                "ietf-ip:ipv4": {
                    "address": [
                        {
                            "ip": ip_address,
                            "netmask": subnet_mask
                        }
                    ]
                }
            }
        }
        
        response = requests.post(
            url,
            auth=self.auth,
            headers=self.headers,
            json=data,
            verify=False
        )
        
        if response.status_code == 201:
            print(f"✅ Loopback{number} created: {ip_address}")
            return True
        else:
            print(f"❌ Error: {response.status_code} - {response.text}")
            return False
    
    def update_interface(self, name, description=None, enabled=None):
        """PATCH - Partially update interface"""
        url = f"{self.base_url}/ietf-interfaces:interfaces/interface={name}"
        
        data = {"ietf-interfaces:interface": {}}
        if description:
            data["ietf-interfaces:interface"]["description"] = description
        if enabled is not None:
            data["ietf-interfaces:interface"]["enabled"] = enabled
        
        response = requests.patch(
            url,
            auth=self.auth,
            headers=self.headers,
            json=data,
            verify=False
        )
        
        if response.status_code in [200, 204]:
            print(f"✅ Interface {name} updated")
            return True
        else:
            print(f"❌ Error: {response.status_code}")
            return False
    
    def delete_interface(self, name):
        """DELETE - Remove interface"""
        url = f"{self.base_url}/ietf-interfaces:interfaces/interface={name}"
        
        response = requests.delete(
            url,
            auth=self.auth,
            headers=self.headers,
            verify=False
        )
        
        if response.status_code in [200, 204]:
            print(f"✅ Interface {name} deleted")
            return True
        else:
            print(f"❌ Error: {response.status_code}")
            return False

# Usage Example
if __name__ == "__main__":
    client = RESTCONFClient('ios-xe.example.com', 'admin', 'cisco')
    
    # READ - Get all interfaces
    client.get_interfaces()
    
    # CREATE - Add loopback
    client.create_loopback(100, 'Test Loopback', '10.1.1.1', '255.255.255.255')
    
    # UPDATE - Modify description
    client.update_interface('Loopback100', description='Updated via RESTCONF')
    
    # DELETE - Remove loopback
    client.delete_interface('Loopback100')