Introduction

Network technologies are evolving at an exceptionally rapid pace, driven by the extensive utilization of information technologies and telecommunication systems across diverse sectors of human activity. Traditionally, network devices employed standard protocols and services to execute their intended functions effectively [1]. However, over time, several limitations and incompatibilities with the contemporary challenges of modern networks have become apparent. These challenges include the exponential increase in the number of users, the proliferation of services, the dramatic rise in the number of devices, and the expansion of communication channels, all contributing to heightened requirements and expectations for network infrastructures [2].

In response to these emerging challenges, new trends have surfaced in the field of network development, particularly focusing on the implementation of Software-Defined Networking (SDN) and Network Functions Virtualization (NFV). These technologies represent a fundamental shift from traditional network architectures, offering enhanced flexibility, scalability, and manageability of network resources. SDN and NFV aim to address the shortcomings of legacy network systems by decoupling network functions from the underlying hardware, thus enabling more dynamic and programmable network environments. This evolution necessitates the development of improved protocols and innovative technologies to meet the current and future demands of advanced information and communication networks and systems [3,4].

The increasing adoption of network function virtualization is a primary factor driving the integration of SDN. SDN and NFV technologies are inherently complementary; while NFV focuses on enhancing the actual network services that manage data flows, SDN provides a robust control plane that governs the overall behavior of the network [5]. This symbiotic relationship enhances the efficiency and effectiveness of network operations, allowing for greater adaptability and responsiveness to changing demands.

The primary objective of this research is to develop a comprehensive simulation environment for implementing and evaluating various network functions and protocol solutions. This environment is intended to serve as a critical tool for conducting experimental research, enabling researchers to test and refine new network technologies and protocols. In the long term, the insights gained from these experimental studies will facilitate the deployment of these innovative solutions within the SDN framework, ensuring they meet the stringent requirements of next-generation information and communication networks [2,3].

First level heading Routing Technology Based on NFV and SDN Concepts

The core of this work is centered around the router, a traditional network device. The primary functions of a router include selecting optimal routes to remote networks, populating the routing table, and forwarding packets between networks [5].

In the routing process, routers consider several alternative routes to reach a single destination. These alternatives are the result of redundancy built into most network designs.

To develop the simulation system, the following were utilized:

• Python programming language;

• Python modules: ipaddress, threading, socket, json, tabulate.

The operation of simulating routers involves many objects interacting with each other [2]. The Simulation object is necessary for storing router objects. It can start all routers simultaneously using the start_routers method and print an interface table with statuses and other information about the interface objects with the print(simulation) method. The router is the primary object in the simulation. It stores interfaces that are necessary for the exchange of information between routers. Additionally, the router maintains a routing table and other essential data about the router. The Router object has several public methods:

• set_protocol: This method sets the dynamic routing protocol object that will run on the router.

• has_ip: This method checks whether a given IP address exists on the router.

• message_to_interface: This method sends a message from a specific interface. It requires the interface number from which the message will be sent and the message itself [6].

• message_to_ip: This method sends a message to a specific IP address. It requires the IP address and the message to be sent. The router will then attempt to find a path for sending it through the connected interfaces or the routing table.

• message_to_broadcast: This method sends a message to the broadcast port. All interfaces with the same broadcast address will receive the message. • set_default_route: This method sets the default route. It requires the IP address, the interface number through which network access is made, and the metric. The metric is necessary to find the quickest way to send the message.

• add_route: This method sets a route to a specific network. It requires the IP address and subnet mask of the remote network, the IP address and interface number through which access to the remote network is made, and the metric [2][3][4][5][6].

• start: This method starts the router. After this, the router begins to listen to the broadcast port and operate the dynamic routing protocol.

The Interface object represents a router interface that can interact with other interfaces for data exchange. The Interface object has the following methods:

• get_ip Returns the IP address of the interface.

• get_conn: Returns the connection object of the interface to another interface.

• connect_to_router: Initiates a series of actions to establish a connection with another interface.

• wait_connection: Waits for a response from another interface to confirm the connection.

• accept_connection: Confirms the connection to another interface.

• listen_conn: Awaits the establishment of a connection with another interface.

To establish a connection between two interfaces, the following steps are necessary: 1. Call the connect_to_router method on the first interface and pass the IP address of the remote interface to which the connection is being created [7,8]. The first interface will then wait for the connection to be established. 2. Call the accept_connection method on the second interface, to which the first interface is connecting, and pass the address of the first interface that wants to connect and its port for connecting the interfaces (local_port) [4][5][6][7][8].

RoutingProtocol is an abstract class designed for creating dynamic routing protocols. It defines the main methods that must be present in all dynamic routing protocols.

RIP is an object created to demonstrate the organization and operation of dynamic routing protocols in the simulation. It has the following methods:

• new_message: Processes the received message addressed to the dynamic routing protocol.

• get_routing_table_to_send: Processes the routing table for further transmission to other routers.

• send_route: Sends the routing table, prepared by the get_routing_table_to_send method, from all router interfaces (to all network neighbors). • runner: Sends messages every n seconds.

• start: Initiates the protocol operation. After execution, the runner method launches a cycle that sends the routing table to all network neighbors every n seconds.

Testing the Developed Routing Technology

To begin the simulation, it is essential to create all necessary objects. This involves generating lists of interface objects by providing parameters such as the interface number, interface port, bandwidth port, and an IPv4Interface object for recording the IP address.

Next, you need to call a method from the simulation object to create and add routers to the simulation. This requires passing the router's name and the interfaces created in the previous step [4][5][6][7][8]. You can create as many routers as needed, but careful attention must be given to the creation of interfaces, as the simulation will only function correctly with properly configured parameters, ensuring no data overlaps between interfaces except for the broadcast port.

Once the routers are set up, they are started, and the message_to_broadcast method is invoked on all routers. This step is crucial for the automatic connection of interfaces sharing the same broadcast port.

The simulation employs a software interface to facilitate data exchange between routers, achieved through inter-process communication mechanisms like sockets [4][5][6][7][8]. Network ports are necessary for socket operations, so during the simulation, these ports must be specified for each interface. Sockets replace the second layer of the OSI model, allowing the creation of socket connections between two software objects and enabling data exchange between them [4][5][6][7][8].

Within the interface object, broadcast sockets are responsible for listening and transmitting data on a designated port. When establishing a connection between two interfaces, a socket connection is created between the ports of these interfaces, enabling data transmission and reception between the two interfaces.

The process of connecting interfaces through socket connections can be summarized as follows:

1. Several routers have some interfaces using the same broadcast port. This setup is illustrated in the following example. • A packet for a regular message via a socket connection looks like this:

{"src_ip": "ip", "dst_ip": "ip", "data": "message"} • A packet for a broadcast message is structured as follows:

{"src_ip": "ip", "src_port": "port", "data": "message"} In the RIP dynamic routing protocol, data is packaged as follows:

{"type": "RIP", "routing_table": None} Once a connection is established between two interfaces, a message can be sent from one interface, received by the other, and processed if necessary [4][5][6][7][8].

Currently, there are no applications that allow for the creation of custom dynamic routing algorithms in Python. To integrate custom code as a dynamic routing protocol into the simulation, the following conditions must be met: the created dynamic routing class must inherit from the abstract class RoutingProtocol; the created class must implement two methods abstractly defined in the RoutingProtocol class. The RIP class can serve as an example for writing custom protocols based on its structure.

By adhering to these guidelines and thoroughly testing the developed routing technology, it ensures that the simulation is robust, reliable, and ready for real-world network environments.

Practical investigation of the developed routing technology

The practical significance of the developed routing technology lies in its ability to implement simulation results (both mathematical and imitative) using the developed technology. This allows for the practical realization of advanced routing methods without changing the actual protocol solutions, which often have numerous shortcomings and do not reflect the features of modern networks, thereby becoming obsolete.

For instance, solving a routing problem with the RIP protocol metric can be modeled as a Boolean programming task using Matlab's tools [9].

Routing problem formulation

Given:

• We need to determine:

• The shortest path from the sender node to the receiver node through the communication channel of the modeled network within the chosen metric. • The dependence of the number of paths used in the routing process on the traffic density entering the network. • The bandwidth of the communication direction from the sender node to the receiver node according to the chosen routing model.

Routing Problem Description as a Boolean Programming Problem Using RIP v.1 Metrics

The number of communication channels in the network (n) determines the size of vector x, where the coordinates 𝑥 !,! represent the share of traffic in the communication channels between the i-th and j-th nodes. The size of the metric vector f also corresponds to the number of communication channels in the network (n), and its coordinates 𝑓 !,! characterize the metric of the communication channels between the i-th and j-th nodes.

To implement routing, the coordinates of vector x are subject to the following constraints:

𝑥 !,! ∈ {0,1} 𝑖, 𝑗 = 1, 𝑚 ; 𝑖 ≠ 𝑗 ,(1

) This means that the variable 𝑥 !,! can only take two values:

• 1, if traffic passes through the channel (i,j);

• 0, otherwise.

This Boolean value (1) ensures that there are no deviations in the flows along the network path, i.e., all traffic is transmitted via a single path.

In the first case, each communication channel is assigned a metric equal to 1 𝑓 !,! = 1, ; 𝑖, 𝑗 = 1, 𝑚; 𝑖 ≠ 𝑗 , corresponding to finding the path with the minimum number of retransmissions (fval) between a given pair of nodes, as in protocol RIP v.1.

When solving the routing problem, it is necessary to ensure the flow conservation conditions for each network node and the network as a whole:

𝑥 !,! !:(!,!) − 𝑥 !,! !: !,! = 1 − for the sender node 𝑥 !,! !:(!,!) − 𝑥 !,! !: !,! = 0 − for the transit node 𝑥 !,! !:(!,!) − 𝑥 !,! !: !,! = −1 − for the receiver node(2)

In addition to the flow conservation condition (2), the condition to avoid link overload must also be satisfied:

𝑟 • 𝑥 !,! ≤ 𝑐 !,! 𝑖, 𝑗 = 1, 𝑛, 𝑖 ≠ 𝑗,(3

) where 𝑐 !,!represents the capacity of the communication channel between nodes I and j.

Solving routing problems in modern network protocols typically involves finding the shortest path in a network, which defines the structure of the communication system. The shortest path problem in a network is formulated as a boolean programming problem, and the "Optimization Toolbox" in Matlab, specifically the "bintprog" subroutine, is used for its solution.

According to the equation ( 1), solving the boolean programming problem requires minimizing the objective function expressed in linear form min ! 𝑓 ! 𝑥 subject to a series of constraints represented as equality and inequality constraints: 𝐴 • 𝑥 ≤ 𝑏; 𝐴𝑒𝑞 • 𝑥 = 𝑏𝑒𝑞, where f, x, b, beq are vectors, and A, Aeq are matrices of corresponding dimensions.

Matlab's environment supports several syntax variants to call the "bintprog" subroutine:

1. 𝑥, 𝑓𝑣𝑎𝑙 = 𝑏𝑖𝑡𝑝𝑟𝑜𝑔 𝑓, 𝐴, 𝑏 solves 𝑓𝑣𝑎𝑙 = min ! 𝑓 ! 𝑥 subject to 𝐴 • 𝑥 ≤ 𝑏. To describe the routing problem in Matlab's formalism, the flow conservation condition (2) should be expressed as a vector matrix: 𝐴𝑒𝑞 • 𝑥 = 𝑏𝑒𝑞. Thus, the matrix Aeq has dimensions 𝑚×𝑛, and its coordinates take values −1; 0; 1 as follows 𝑗 = 1, 𝑚, 𝑖 = 1, 𝑛 :

𝑎 !" = 1, if the i-th communication channel goes from node j; 𝑎 !" = −1, if the i-th communication channel enters node j; 𝑎 !" = 0 , if the i-th communication channel does not involve node j. The size of the vector beq corresponds to the number of nodes in the network (m), and its coordinates are generated as follows 𝑗 = 1, 𝑚 :

𝑏𝑒𝑞 ! = 1 if the i-th node is a packet sender; 𝑏𝑒𝑞 ! = −1 if the i-th node is a packet receiver; 𝑏𝑒𝑞 ! = 0 if the i-th node is a retransmitter. Conditions(3)

should also be expressed as a vector matrix with inequality 𝐴 • 𝑥 ≤ 𝑏.

As an example of a metric routing problem for the RIP v.1 protocol, formulated and solved in Matlab:

The number of communication channels in the network (n) determines the size of vector x, where the coordinates 𝑥 !,! represent the share of traffic in the communication channels between the i-th and j-th nodes. The size of the metric vector f also corresponds to the number of communication channels in the network (n), and its

Let the network structure and channel capacities be shown in Fig. 5. The total number of nodes in the network is five (m = 5), and the number of communication channels is six ( n = 6). Then, the packet sender node is 1, and the receiver node is 5. Let's formulate vector x and metric vector f :

𝑥 = 𝑥 !,! 𝑥 !,! 𝑥 !,! 𝑥 !,! 𝑥 !,! 𝑥 !,! 𝑓 = 𝑓 !,! 𝑓 !,! 𝑓 !,! 𝑓 !,! 𝑓 !,! 𝑓 !,! = 1 1 1 1 1 1 .

Formulate the flow conservation conditions for network nodes (2):

𝑥 !,! + 𝑥 !,! = 1; −𝑥 !,! + 𝑥 !,! + 𝑥 !,! = 0; −𝑥 !,! − 𝑥 !,! + 𝑥 !,! = 0; −𝑥 !,! + 𝑥 !,! = 0; −𝑥 !,! − 𝑥 !,! = −1.

Formulate the matrix Aeq and the vector beq:

𝐴𝑒𝑞 = 1 1 0 0 0 0 -1 0 1 1 0 0 0 -1 -1 0 1 0 0 0 0 0 -1 1 0 0 0 -1 0 -1 ; 𝑏𝑒𝑞 = 1 0 0 0 -1 .

Formulate overloading of communication channels (3):

𝑟 • 𝑥 !,! ≤ 𝑐 !,! ; 𝑟 • 𝑥 !,! ≤ 𝑐 !,! ; 𝑟 • 𝑥 !,! ≤ 𝑐 !,! ; 𝑟 • 𝑥 !,! ≤ 𝑐 !,! ; 𝑟 • 𝑥 !,! ≤ 𝑐 !,! ; 𝑟 • 𝑥 !,! ≤ 𝑐 !,! .

Formulate the matrix A and the vector b 𝐴 = 𝑟 0 0 0 0 0 0 𝑟 0 0 0 0 0 0 𝑟 0 0 0 0 0 0 𝑟 0 0 0 0 0 0 𝑟 0 0 0 0 0 0 𝑟

; 𝑏 = 1 0 0 0 -1 .

In the example provided above, the program code appears as shown in Figure 6. Calculation results are displayed in the command window (Figure 6). According to these results, the "length" of the shortest path is 2 ( fval = 2), with 𝑥 !,! = 1 and 𝑥 !,! = 1, indicating that it passes through nodes 1, 2, and 5 (Figure 7). Figure 7 illustrates the traffic intensity passing through the communication channel. As a result, it is necessary to construct a graph showing the number of paths (K) used in the routing process as a function of the traffic intensity (r) entering the network. The graph should also indicate which paths are used at which traffic intensities. Additionally, it is worthwhile to experimentally determine the bandwidth capacity in the communication direction from the sender node to the receiver node according to the implemented routing model.

The implementation of the described routing model using the Matlab mathematical package and developed technology has demonstrated analogous routing results.

Impact of Machine Learning on SDN/NFV-based Routing

The integration of Machine Learning (ML) with Software-Defined Networking (SDN) and Network Functions Virtualization (NFV) is revolutionizing network routing strategies. This synergy enhances network performance, adaptability, and efficiency. This section explores the transformative role of ML in SDN/NFV-based routing systems.

2. Data Quality and Availability: The effectiveness of ML models heavily depends on the quality and quantity of available network data.

3. Model Interpretability: Some ML models, particularly deep learning models, lack interpretability, which can be a concern in critical network operations.

4. Security Implications: The use of ML in routing decisions introduces new attack vectors that need to be addressed.

Future research should focus on developing lightweight ML algorithms suitable for real-time network operations, improving the interpretability of ML models in networking contexts, and addressing the security challenges associated with ML-driven routing systems.

The integration of Machine Learning with SDN/NFV-based routing represents a significant advancement in network management and optimization. By leveraging ML algorithms, networks can become more adaptive, efficient, and intelligent in their routing decisions. As this field continues to evolve, we can expect to see increasingly sophisticated routing solutions that can handle the complex demands of modern network environments. The synergy between ML, SDN, and NFV is paving the way for next-generation networks that are not only programmable and virtualized but also self-optimizing and predictive in nature.

Conclusions

In conclusion, it can be confidently asserted that the scientific and technical advancements in Software-Defined Networking (SDN) bring significant benefits to both data center enterprises and researchers exploring new network mechanisms and protocols. These advancements enable researchers to conduct more realistic experiments, while providing data center enterprises with tools to enhance their network infrastructures.

The emulation of network devices and their functionalities empowers stakeholders to develop and adapt their own standards, offering unparalleled flexibility in the design and management of corporate and global networks. This article has presented a methodological approach for developing and modifying network functions, accompanied by a robust testing environment for evaluating newly created dynamic routing protocols.

The study details a comprehensive modeling workflow, facilitating the validation of dynamic routing protocols implemented in Python across diverse network configurations involving any number of routers and interconnections. Furthermore, the implementation of a routing model based on the RIP protocol using Matlab's mathematical capabilities has corroborated the routing outcomes achieved through the innovative Python-based routing technology developed herein.