How boss-server-ops/minindn works
Project Type & Purpose
• Mini-NDN is essentially an emulation and experimental platform for NDN networks, wrapping around Mininet and integrating core NDN components (such as NFD and NLSR).
• It supports testing and research via simulation and experimentation of network protocols and behaviors.
• The README confirms its role to help users build, run, and experiment with emulated NDN networks.
File Structure to Define Architectural Domains
• Core Emulation & Orchestration:
– The “minindn” directory is a Python package that contains the orchestration logic (app manager, configurations, and helper modules for interfacing with NFD, NLSR, and tshark).
– Also in “minindn” are subdirectories for applications and network monitoring (for example, the “helpers” and “wifi” folders).
• Application Implementations:
– The “apps” directory (and its subdirectories like “algorithm”) hold many C++ based components that implement network functions such as producers, consumers, aggregators, and routing algorithms (e.g., k-means, network simplex, aggregation trees).
– “catapps”, “putapps”, and “yulongapp” provide additional app implementations and tests, likely representing different approaches or experimental modules that interact with the underlying NDN simulation.
• Topology and Configuration:
– The “topologies” directory houses various configuration files that define network topologies (data centers, ISP topologies, binary trees, WiFi layouts) that will be used to configure the emulated networks.
– Also, “experiments” and “examples” provide scripts and Jupyter notebooks that demonstrate usage as well as experimental setups.
• Deployment & Build:
– Docker-related files (Dockerfile, the docker directory) and Vagrant configurations illustrate containerized deployment options, helping the system run in a consistent environment.
– Makefiles in “apps”, “catapps”, “putapps”, and documentation in “docs” outline the build and documentation processes.
– The “requirements.txt” and “setup.py” point to Python dependencies which are crucial for the orchestration layer.
Key Components & Their Relationships
a. Emulation Orchestrator (minindn package):
– Acts as the master control unit where simulation parameters, application orchestration, and experiment management are handled.
– Interfaces with external NDN components (NFD, NLSR) as well as system utilities (e.g., tshark for packet monitor).
b. Application Nodes:
– The C++-based “apps” (and variations like “catapps”, “putapps”, “yulongapp”) implement the functionalities of NDN routing, data aggregation, and network behavior tests.
– They are “plugged” into the emulation environment defined by the orchestration layer.
– Specific modules under “apps/algorithm” indicate the use of sophisticated algorithms (aggregation, k-means clustering, network simplex, etc.) for network optimization and simulation.
c. Topology/Configuration Files:
– Define the network topology (node connectivity, link parameters) and experiment settings, providing the input for the orchestration layer.
– The relationship is that once a topology is selected, the emulation orchestrator configures the simulation accordingly.
d. Deployment & Build Tools:
– Tools like Docker, Vagrant, and Makefiles ensure that the system can be built, tested, and deployed consistently across environments.
– They are not part of the runtime architecture but are critical for the development and deployment lifecycle.
Architectural Patterns & Design Principles
• Layered Separation: The design clearly separates the emulation/orchestration layer (Python modules) from the performance-critical application implementations (C++ apps).
• Modular and Extensible: The presence of multiple “apps” directories and diverse topology configurations suggests that the system is designed for plug-and-play testing scenarios.
• Deployment Abstraction: Docker and Vagrant support a containerized and virtualized architecture, so include these as “environment provisioning” modules.