The Network Control Plane (NCP) is an asynchronous, web-based orchestration layer designed to streamline NETCONF-driven device interactions. Developed for high-concurrency internal engineering environments, NCP abstracts complex CLI operations into a centralized, GUI-driven workflow. By leveraging a non-blocking architecture, the system enables engineers to execute Remote Procedure Calls (RPCs) and manage device configurations without the latency associated with traditional synchronous terminal sessions.
The system adheres to a robust Model-View-Controller (MVC) pattern, decoupling the user interface from the heavy I/O operations required for network communication.
- Backend Framework: Flask (Python-based micro-framework)
- Asynchronous Processing: Celery (Distributed Task Queue)
- Message Broker: Redis
- Frontend Interactivity: HTMX (Server-driven UI updates)
- Database: SQLite3 (Session management and audit logging)
- Data Transformation: Python-based parsers for XML, JSON, and YAML conversion
- The View (UI Layer): Utilizing Jinja2 templates and HTMX, the frontend provides a real-time dashboard. HTMX allows for partial page updates, enabling operational logs and device states to stream to the user without full page refreshes.
- The Controller (Logic Layer): The Flask API handles request orchestration, input validation, and security protocols. It manages the hand-off between the web layer and the worker nodes.
- The Model (Data & Task Layer): SQLite3 stores encrypted session data and historical device interactions. Background workers (Celery) execute the actual NETCONF logic, ensuring the web interface remains responsive.
To prevent request timeouts during long-running network operations, NCP utilizes a decoupled execution model. When a user triggers an action, the Flask frontend validates the request and pushes it to a Redis queue. Celery workers pick up the task, establish a NETCONF session, and execute the RPC. The status is then reported back to the UI via asynchronous polling or socket-like updates.
Network devices natively communicate via XML. NCP implements a transformation pipeline that sanitizes and converts raw XML into structured JSON for internal processing, eventually rendering it as YAML in the GUI for human readability. This ensures that complex configuration states are easily digestible for troubleshooting.
To ensure system stability, NCP executes pre-flight TCP checks before initiating a NETCONF session. This prevents worker deadlock and I/O errors by verifying device availability and port accessibility prior to task allocation.
The tool utilizes encrypted cookies and session models to provide device history suggestions. This reduces manual input errors and accelerates the workflow for engineers managing high-density network clusters.
In its initial 40-day deployment phase, NCP demonstrated significant operational improvements:
- Workflow Volume: Successfully executed over 290 automation workflows.
- Execution Accuracy: Achieved an 85% success rate, including the identification of pre-flight TCP failures.
- Efficiency Gains: Reduced manual CLI dependency by approximately 30 to 60%.
- Troubleshooting: Improved MTTR (Mean Time to Repair) by 40 to 70% through centralized operational state visualization.
Due to Non-Disclosure Agreements (NDA), the source code and specific execution logic for this project are not publicly available. This tool was developed as a proprietary internal engineering solution specifically for Nokia-based OLTs, NTs, and LTs. This documentation serves as a conceptual and architectural overview of the work performed.