Software Defined Networks are coming to leverage the power of the networks, defining controllers to manage the network elements simplifying the configuration, bringing flexibility and blablabla ... But ... how to program and manage this new monster?

1. Network
Programming Languages
Author: Flavio Vit
Course: UNICAMP –MO611
Teleprocessamento e Redes
Professor: Nelson da Fonseca
June 18, 2014

2. Agenda
• Introduction
• Flog
• Nettle
• FatTire
• Comparisons

3. Introduction
• Flog: Logic Programming for Software-Defined
Networks
• Nettle: Taking the Sting Out of Programming
Network Routers
• FatTire: Fault Tolerating Regular Expressions

4. Networks Management
In the past …
• Networks managed through a set of complex,
low-level, and heterogeneous interfaces
• Firewalls + network address translators + load
balancers + routers + switches == Configured
separately
• Thousands of lines low-level code in different
domain-specific languages
• Complex routing mechanisms (error-prone tasks)

5. Software Defined Networks
Recently …
• SDN – Software Defined Networks
• Logically centralized Controller:
– Managing distributed switches
– General purpose machines
– Working on routing decisions
– Instruct the switches to install the necessary
packet-forwarding rules.

6. Flog - An SDN Logic Programming
Language
• SDN packet-forwarding rule
 Predicate + Action + Priority
• Example:
 Predicate: match packets based on the IP header
(MAC, IP, etc.)
 Action: Drop, forward or flood the packet to ports
 Priority: rules are executed according with priorities

7. Flog
• Combines two programing languages:
– FML:
• set of high-level built-in policy operators (SDN abstractions)
• allow/deny certain flows
• provide quality of service
• Programing model Not flexible
– Frenetic:
• declarative query language - SQL-like syntax
• functional stream-processing language
• language for describing packet forwarding

8. Flog
• From FML:
– Programming for controlling software-defined
networks
• From Frenetic:
Controller programs split into :
1. Mechanism for querying network state
2. Mechanism for processing data extracted from
queries
3. Component for generating packet-forwarding policies
(automatically push to the switches)

9. Flog
• Event driven => execution of logic programs
1. Generates a packet-forwarding policy
compiled and deployed on switches
2. Generates states : drive the logic program when
the next network event is processed

10. Flog
• Network Events:
– Switches online / offline
– Ports on switches active / inactive
– Statistics gathered by switches
– Packets arrive at the controller and require
handling

11. Flog
• Flow rule syntax example:
flow(srcip=IP,vlan=V), V > 0 --> myvlans(IP,V)
• When vlan tag is greater than 0, generate a
network event every time a packet with a new
srcip - vlan tag pair is detected
• When this event generated, the rest of the
logic program will be executed.
• The initial data for the logic program will
include the tuple myvlans(IP,V)

12. Flog
Police Generation:
• generating a routing policy for network switches:
h1(F1), h2(F2), ... |> action, level(i)
left of the |> : kinds of packets that match the forwarding
rule. Specifies the packet fields (and switch and ports) that
match the rule.
right of the |> :
action where to forward or flood the packets or how
to modify them.
level specifies the priority of the rule.

13. Flog
• Example:
# Network Events
flow(dstip=IP), inport=2 --> seen(IP)
# Information Processing
seen(IP) +-> allow(IP)
allow(IP) +-> allow(IP)
# Policy Generation
inport(2) |> fwd(1), level(0)
allow(IP) -->
srcip(IP), inport(1) |> fwd(2), level(0).

14. Nettle - Taking the Sting Out of
Programming Network Routers
• Networks of OpenFlow switches controlled using
a high-level, declarative and expressive language
• Based on the principles of functional reactive
programming (FRP)
• Embedded in Haskell => general-purpose purely
functional programming language.
• Domain Specific Language

15. Nettle
• Layered architecture
Family of DSLs - each member
capturing a different network
abstraction
Haskell host language
OpenFlow switches
Nettle / OpenFlow lib
instantiation of the Functional Reactive
Programming

16. Nettle
• Nettle/FRP  as a language for expressing
electrical circuits
• Haskell’s arrow syntax:
y ← sigfun −≺ x

17. Nettle
• Focus on the stream of control messages
among OpenFlow switches
• Nettle => powerful collection of
– Signal functions
– Event operators

18. Nettle
OpenFlow switches maintains flow table with
flow entries:
match IPs, header fields
• Forwarding actions to specific ports, flooding,
dropping packets
are updated
• Expirations settings expires a flow entry after
prescribed time

19. Nettle
• Nettle Controller transforms:
stream of messages from switches
stream of commands for switches

20. Nettle
• Example: install the flow rule, whenever a
switch joins the network

21. FatTire: Fault Tolerating Regular
Expressions
• Programs for fault tolerant Networks
• Based on regular expressions
• Main features:
Expressive: easy to describe forwarding and fault
tolerant policies
Efficient: based on fast failover from OpenFlow
Correct: reasoning about the behavior of the
system during failure recovery

22. FatTire
• Central feature: Regular expressions for sets
of legal paths through the network
• FatTire programs are translated to OpenFlow
switch configurations
• Automatic response to link failures with no
controller intervention

23. FatTire
• Example :OpenFlow Group and Route Tables

24. FatTire
• Group and Rule Tables for previous slide

25. FatTire
• Syntax:

26. FatTire
• FatTire program for this example
Security policy: All
SSH traffic must traverse the IDS
- regular expressions
over switches to describe legal
paths
Fault-tolerance policy: “with”
annotation
Forwarding must be resilient to
a single link failure.
Routing policy:
Traffic from the gateway (GW)
must be forwarded to the
access switch (A), along any
path

27. Comparisons
Prog Lang Main Characteristic Advantages Disadvantages
Flog - Network Event
driven
- Focused on packets
flow
- Simple
- Combines Frenetic
and FML
Too simple and
limited to flow
control
FatTire Targets fast failover
mechanisms provided
by OpenFlow standard
- High level
- Regular expression
powered
- Turns failover
scenarios easier to
understand
Only focused over
solving link failures
configuration
Nettle - allow fine-grained
control over switch
behavior
- event-based
programming model
- Strong typed
- Extensible
Good question!!!
I buy it!

28. References
1. Naga Praveen Katta, Jennifer Rexford, and David Walker. Logic
Programming for Software-Defined Networks
1. Mark Reitblatt, Marco Canini, Arjun Guha, and Nate Foster.
Fattire: Declarative fault tolerance for software defined
networks
1. Andreas Voellmy and Paul Hudak. Nettle: Taking the Sting Out
of Programming Network Routers