David Lebrun

Towards test-driven software defined networking

To configure, troubleshoot and operate their networks, operators often have no alternatives than relying on error-prone manual procedures. The emerging Software Defined Networking paradigm opens new possibilities for more structured networking methodologies.We argue that provably-effective practices can be borrowed from more developed engineering fields, especially software engineering. In this paper, we propose an adaptation of test-driven software development methodologies to software defined networks (SDNs). To support our methodological guidelines, we propose an expressive requirement formalization language. Further, we describe a prototype tool able to check the compliance of an SDN controller with requirements expressed in the proposed language. Our evaluation of the prototype shows promising results on the practical viability of our approach.

SCMon: Leveraging segment routing to improve network monitoring

To guarantee correct operation of their networks, operators have to promptly detect and diagnose data-plane issues, like broken interface cards or link failures. Networks are becoming more complex, with a growing number of Equal Cost MultiPath (ECMP) and link bundles. Hence, some data-plane problems (e.g. silent packet dropping at one router) can hardly be detected with control-plane protocols or simple monitoring tools like ping or traceroute. In this paper, we propose a new technique, called SCMon, that enables continuous monitoring of the data-plane, in order to track the health of all routers and links. SCMon leverages the recently proposed Segment Routing (SR) architecture to monitor the entire network with a single box (and no additional monitoring protocol). In particular, SCMon uses SR to (i) force monitoring probes to travel over cycles; and (ii) test parallel links and bundles at a per-link granularity. We present original algorithms to compute cycles that cover all network links with a limited number of SR segments. Further, we prototype and evaluate SCMon both with simulations and Linux-based emulations. Our experiments show that SCMon quickly detects and precisely pinpoints data-plane problems, with a limited overhead.

Traffic duplication through segmentable disjoint paths

Ultra-low latency is a key component of safety-critical operations such as robot-assisted remote surgery or financial applications where every single millisecond counts. In this paper, we show how network operators can build upon the recently proposed Segment Routing architecture to provide a traffic duplication service to better serve the users of such demanding applications. We propose the first implementation of Segment Routing in the Linux kernel and leverage it to provide a traffic duplication service that sends packets over disjoint paths. Our experiments show that with such a service existing TCP stacks can preserve latency in the presence of packet losses. We also propose and evaluate an efficient algorithm that computes disjoint paths that can be realised by using segments. Our evaluation with real and synthetic network topologies shows that our proposed algorithms perform well in large networks.

Implementing IPv6 Segment Routing in the Linux Kernel

IPv6 Segment Routing is a major IPv6 extension that provides a modern version of source routing that is currently being developed within the Internet Engineering Task Force (IETF). We propose the first open-source implementation of IPv6 Segment Routing in the Linux kernel. We first describe it in details and explain how it can be used on both endhosts and routers. We then evaluate and compare its performance with plain IPv6 packet forwarding in a lab environment. Our measurements indicate that the performance penalty of inserting IPv6 Segment Routing Headers or encapsulating packets is limited to less than 15%. On the other hand, the optional HMAC security feature of IPv6 Segment Routing is costly in a pure software implementation. Since our implementation has been included in the official Linux 4.10 kernel, we expect that it will be extended by other researchers for new use cases.

Software Resolved Networks: Rethinking Enterprise Networks with IPv6 Segment Routing

Enterprise networks often need to implement complex policies that match business objectives. They will embrace IPv6 like ISP networks in the coming years. Among the benefits of IPv6, the recently proposed IPv6 Segment Routing (SRv6) architecture supports richer policies in a clean manner. This matches very well the requirements of enterprise networks. In this paper, we propose Software Resolved Networks (SRNs), a new architecture for IPv6 enterprise networks. We apply the fundamental principles of Software Defined Networks, i.e., the ability to control the operation of the network through software, but in a different manner that also involves the endhosts. We leverage SRv6 to enforce and control network paths according to the network policies. Those paths are computed by a centralized controller that interacts with the endhosts through the DNS protocol. We implement a Software Resolved Network on Linux endhosts, routers and controllers. Through benchmarks and simulations, we analyze the performance of those SRNs, and demonstrate that they meet the expectations of enterprise networks.

A Linux kernel implementation of Segment Routing with IPv6

Network operators seek more flexibility to provide added-value services to their customers. We propose to leverage the IPv6 Segment Routing architecture with a example usecase. We also provide an implementation of SR-IPv6 and we evaluate its performance on broadband routers.

IPv6 Segment Routing to the End Host: A Linux Kernel Implementation: Demo

Segment Routing (SR) is already deployed in its MPLS variant. We focus on its IPv6 flavor (SRv6) and argue that it enables the hosts to directly participate in the management of their flows, through an SDN-like controller. To realise this, we implement SRv6 in the Linux kernel. Our implementation has been merged in the mainstream Linux tree and is available as of Linux 4.10. We argue that such a public, open-source implementation enables other researchers to explore SRv6. We propose a demonstration of our implementation.