GSoC Projects

Untitled Document.md

Summary

Flowgrammable is an organization that develops Software Defined Networking (SDN) related tools and frameworks. Here is a listing of our proposed Google Summer of Code 2015 projects that we will mentor. All of our projects relate to the OpenFlow protocol and architecture. Applicants must have a basic familiarity with networking concepts, experience with C, C++, python, or html/javascript depending on the project, and are expected to gain a basic understanding of aspects of the OpenFlow protocol.

Candidate Expectations

Candidates are expected to work within the Flowgrammable development environment. The development environment includes a standarized virtual machine, based on Arch Linux, and git repositories maintained on both http://github.com/flowgrammable. The candidate should be familiar with basic development in a linux/unix environment and software repository concepts. The candidate will be expected to familiarize themselves with git and the Flowgrammable CMake based build system. All work performed by the candidate must follow Flowgrammable's established coding guidelines. Candidates are expected to attend Flowgrammable's weekly development meeting, and will be required to hold semi-weekly meetings with their project mentors.

Project Listings

Our projects have been organized into the following subsections: protocol stack, applications, conformance benchmarking, and performance benchmarking. Protocol stack work involves working on some aspect of the Flowgrammable OpenFlow stack, which is called FreeFlow. Applications works involve implementing traditional network functionality as virtual network elements on top of a OpenFlow framework. Conformance and performance benchmarking work will involve helping devise conformance or performance frameworks for testing all aspects of the OpenFlow ecosystem: stacks, switches, controllers, applications, proxies, etc.

Flowsim

Flowsim is a web-based OpenFlow dataplane simulator that enables the users to configure their own OpenFlow switches, issue OpenFlow messages, inject custom packet sequences into the data plane, and observe the resulting behavior. During a simulation the life cycle of an injected packet is visualized as it traverses the OpenFlow data plane. The user is presented with visualizations that included packet arrival, key extraction, table selection, flow selection, and action application. We are looking for candidates that have experience in web development as well as software defined networking.

FlowSim/GitHub Integration

Problem Description

Flowsim currently lacks the ability to share simulation assets such as packets, profiles, switch configs, and traces. We would like users of Flowsim to be able to use Github accounts for asset storage and revision control.

Qualifications

A successful candidate will be familiar with Git, RESTful APIs, and javascript.

Requirements & Goals

A user of Flowsim will create the repository https://github.com/<user>/flowsim/, and subdirectories: packet/, profile/, switch/, and simulation/. The user should be able to store and load assets from their Github repository.

Procedures

  • Familiarize yourself with Flowsim architecture
  • Integrate Flowsim backend with Github by using OAuth2 protocol
  • Features include being able to commit changes to assets through the Flowsim UI

Asset Import/Export into Flowsim

Problem Description

Currently Flowsim requires users to manually create assets. We would like users to be able to import and export the assets into/from user workspaces in common external formats. Flowsim assets are data sources that describe and can be used in simulations.

Qualifications

A successful candidate will be familiar with AngularJS, NodeJS, pcap traces and OpenFlow table type profiles.

Procedures

  • Familiarize yourself with Flowsim architecture
  • Develop a frontend & backend asset-manager module
  • Asset-manager should be extendable through the use of plugins
  • Packet plugin should support importing pcap files to user workspace

Allow the import and export of assets into/from user workspaces in common external formats. Flowsim assets are data sources that describe and can be used in simulations. Rather than manually creating all assets for a simulation, users should be able to import data sets and export modifications in appropriate formats.

Some examples include:

  • Pcap traces to synthesize a sequence of packets.
  • OpenFlow TTP (Table Type Profiles) to describe flow tables for a switch profile.
  • Open vSitch... for something?
  • Others?

Trace Viewer

Problem Description

Currently Flowsim users are unable to see a log of their trace. A user should be able to see a log of all events that occured during the simulation

Qualitifactions

A successful candidate will be familiar with AngularJS, NodeJS, and Flowsim architecture.

Requirements & Goals

Provide a collapsible, hierarchical, log viewer for display of trace events: packet arrivals, configuration events, and pipeline execution steps.

Procedures

  • Familiarize yourself with Flowsim architecture
  • Develop a frontend log viewer
  • Log viewer should have an easy to use GUI

Group actions and processing

Problem

Flowsim is currently lacking support for OpenFlow groups.

Qualifications

A sucessful candidate will be familiar with javascript, and all versions of the Openflow protocol.

Requirements & Goals

Integrate profile, switch, and simulation support for group actions. Group actions are specialized processing functions for packets.

Procedures

  • Familiarize yourself with Flowsim architecture
  • Implement group functionality as well as visualizations

Metering

Integrate profile, switch, and simulation support for meters. A meter specifies an upper bound on the rate of transmission for a flow. When a flow exceeds a specified rate, its packets might be dropped or modified to indicate excess.

PacketIn & PacketOut

Update the simulation view to clearly show packet-in events. These events are triggered when a flow action sends a packet to the controller (e.g., on a table-miss). Update the trace editor to support creation and placement of packet-out messages.

Notion of Time

Update packet traces to allow for time of arrival, if not specified use maximum allowable rate based on packet size and ingress interface speed. Stages from pipeline will need to have a construction parameter of processing time.

Play/Pause, Breakpoints

Support setting breakpoints on stages, packets, flows, groups, meters, packet counts, accumulated bandwidth, and simulation time. Allow course granular steps, which execute a stage in one step. Allow play to run a simulation until completion or a breakpoint has been encountered.

Configuration Events

Extend a simulation to include switch configuration events.

Network Topology

Allow the user to create more than one network element in a simulation. Provide a topology editor for managing port connectivity. Update the simulation views to follow a packet between network elements.

Controller

Allow the user to configure a controller and place controller instances in a simulation. Controller programs are Javascript modules that use the tinyNBI API.

User Definable Pipeline

Provide the user with a pipeline editor supporting user definable pipeline (inspired by Click Modular Router).

User Definable Stages

Publish the pipeline/stage interface specification and support user definable stages.

OpenFlow Stack

Flowgrammable developed and submitted a OpenFlow stack for the Open Networking Fondation (ONF) OpenFlow Driver Competition last summer. This submission forms the basis of FreeFlow, an open source (Apache 2 licensed) OpenFlow Stack. We need successful candidates to help improve the stack by adding various facilities for improved debugging and performance analysis.

Pretty Printer

Problem Description

The Flowgrammable pretty printing facilities need to be greatly improved. Currently, the pretty printer is built on the back of the to_string function, which takes a Message (or message substructure) and a Formatter and creates a new string. We'd like to re-engineer the pretty printer to generate nice output directly to a string and to stream with more closely integrated formatting options (like C++'s iostreams and iomanip) library.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. The candidate will be expected to familiarize themselves with several new language features present in C++11 as they are featured within the OpenFlow stack.

Requirements & Goals

The new library should be separate from the message layer and linked explicitly into client applications. Not all applications will need to pretty print messages, but it is useful for debugging.

The deliverables for this project will be the newly designed pretty printer facility and its application to all messages and message substructures supported by the FreeFlow stack. The design of the facility must be user-friendly, in the sense that it is easy and intuitive to use.

Procedures

  • Familiarize yourself with the to_string facilities in FreeFlow.
  • Design a new set of facilities to more effectively and efficiently generate strings
  • Specific features include scoping, tabbing, and name/value association
  • Replace the existing mechanism

Meaningful Error Messages

Problem Description

The current error system relies on numeric error codes and associated data to indicate specific kinds of errors during protocol processing. The goal of this project is to design and implement a framework for generating meaningful feedback (text) based on those error codes and any associated data. Ideally, this would work like strerror(), returning a string for a given error code.

Because the Error object can include optional data, message generation must incorporate some interpretation of that data in the generated error string. This could include information like the number of bytes being overflowed, an invalid port or table id, an invalid flag, or something even more complex.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. The candidate will be expected to familiarize themselves with several new language features present in C++11 as they are featured within the OpenFlow stack.

Requirements & Goals

A system capable of generating meaningful error messages as strings.

Procedures

  • Familiarize yourself with the FreeFlow error facilities
  • Learn the sets of errors in the FreeFlow protocol errors
  • Design facilities for generating strings that represent those errors
  • The facilities must incorporate system errors as well as protocol error messages.

Exception-based Error Messages

Problem Description

FreeFlow's current error handling approach is to embed error information in an Error object that is propagated using return values. An alternative approach to error handling is to use exceptions. However, extensive use of exceptions in high-performance applications is often discouraged, although this advice may be allegorical and no longer meaningful. Exceptions also provide a greater degree of flexibility in terms of propagating different types of errors.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. The candidate will be expected to familiarize themselves with several new language features present in C++11 as they are featured within the OpenFlow stack.

Requirements & Goals

The goal of this project is to determine whether or not an exception-based error handling perform on par with the existing approach. The project requires the design of a new error handling system for FreeFlow and its integration throughout the OpenFlow protocols. The exception-based implementation must be compared against error-testing implementing to determine the performance benefits or penalties of the model.

Procedures

  • Familiarize yourself with the FreeFlow error facilities
  • Design an exception class that encapsulates FreeFlow error codes
  • Create a branch of FreeFlow that uses exceptions instead of Error codes and Traps
  • Design a test suite that compares the performance of FreeFlow with and without exceptions

Flow Cache

Problem Description

In a software defined network, the load on the controller is extremely high. It has to process thousands of messages per minute when connected to a typical medium sized network. In addition to this, the communication delay across the controller switch channel leads to additional delays.  To solve this problem, this project proposes to implement a flowcache - a device which sits in the middle of the controller and the switch. It supervises all the interactions from the switch to the controller, while caching all the flow entries inserted by the controller in the switch. It acts as a mini controller having the capabilities to take some small set of decisions on behalf of the controller.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. The candidate will be expected to familiarize themselves with several new language features present in C++11 as they are featured within the OpenFlow stack.

Requirements & Goals

Modules to be implemented.

  • A caching system which maintains all the flows even after their expiry.
  • Capability of interpreting openflow messages. Use the message layer of standard openflow stack - Flowgrammable.
  • A decision making module API which interacts with the incoming messages and takes decision accordingly.
  • Small set of controller capabilities, implemented using the above API.

Facts regarding flowcache

It has a storage space much larger than a regular openflow switch.This allows it to cache high number of flows, and take decisions based on them.It is located at a small distance from the switch, leading to a small communication delay between itself and the switch.

Procedures

  • Familiarize yourself with the Flowgrammable development environment
  • Familiarize yourself with the OpenFlow Flowgrammable stack
  • Develop an abstract model of a flow cache (capacity miss, eviction strategy)
  • Propose an application design which includes:
    • Network topology diagram
      • Sequence diagrams: flowmod under capacity, flowmod over capcity, packet event with local entry, packet event with local miss, packet event with cache miss
      • Devise functional test for each sequence
      • Implement and verify application

OpenFlow Applications

The OpenFlow stack should contain a set of basic network functions: learning bridge, static router, nat, and load balancing, etc. These applications, typically called Network Function Virtualization (NFV), need to be developed for FreeFlow library using the OpenFlow stack. Candidates may propose any of the request applications or porpose additional NFV applications using the OpenFlow stack

802.1d Learning Bridge

Problem Description

The goal of this project is to develop a 802.1q learning bridge application for the FreeFlow stack.  The learning bridge will be written as a FreeFlow controller application. 

Qualifications

A successful candidate will be familiar with C++ and basic template programming. Additionally, the candidate is expectd to have basic proficiency in networking. The candidate will be expectd to familiarize themselves with the basic events of an OpenFlow application.

Requirements & Goals

The deliverables for this project will be a fully compliant 802.1D learning bridge application that is compatible with OpenFlow versions 1.0, 1.1, 1.2, 1.3, and 1.3.1. A user should be able to run this application on the FreeFlow controller regardless of the OpenFlow version that the network is running.

Procedures

  • Familiarize yourself with the Flowgrammable development environment
  • Familiarize yourself with the OpenFlow Flowgrammable stack
  • Develop an abstract model of a 802.1q learning bridge (mac learning, packet forwarding, table pruning)
  • Propose an application design which includes:

    • Network topology diagram
    • Sequence diagrams: new source MAC, new source Port, known destination, unknown destination, table miss, table miss due to mac age, table pruning
    • Devise functional test for each sequence
    • Implement and verify application

RFC 1812 Static Router

Problem Description

The goal of this project is to develop a router application for the FreeFlow stack.  The router will be written as a FreeFlow controller application. 

Qualifications

A successful candidate will be familiar with C++ and basic template programming. Additionally, the candidate is expectd to have basic proficiency in networking. The candidate will be expectd to familiarize themselves with the basic events of an OpenFlow application.

Requirements & Goals

The deliverables for this project will be a fully compliant RFC 1812 router application that is compatible with OpenFlow versions 1.0, 1.1, 1.2, 1.3, and 1.3.1. A user should be able to run this application on the FreeFlow controller regardless of the OpenFlow version that the network is running.

Procedures

  • Familiarize yourself with the Flowgrammable development environment
  • Familiarize yourself with the OpenFlow Flowgrammable stack
  • Develop an abstract model of the router (interfaces, subinterfaces, fib, arp, icmp, igmp)
  • Propose an application design which includes:

    • Network topology diagram
    • Sequence diagrams: packet event nexthop, packet event local interface, packet event local delivery, packet event no route, packet event over mtu
    • Devise functional test for each sequence
    • Implement and verify application

IPv4/IPv6 NAT

Problem Description

Implement network/port address translation with FreeFlow. It will be implemented as a controller application. This application must support basic IPv4/IPv6 bidirectional address and port translation with an OpenFlow based switch. The translations must be able to be configured by the user.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. Additionally, the candidate is expectd to have basic proficiency in networking. The candidate will be expectd to familiarize themselves with the basic events of an OpenFlow application.

Requirements & Goals

The deliverables for this project will be NAT application that supports IPv4 and IPv6 addresses, which is compatible with OpenFlow versions 1.0, 1.1, 1.2, 1.3, and 1.3.1. A user should be able to run this application on the FreeFlow controller regardless of the OpenFlow version that the network is running.

Procedures

  • Familiarize yourself with the Flowgrammable development environment
  • Familiarize yourself with the OpenFlow Flowgrammable stack
  • Develop an abstract model of the NAT (pool interfaces, pool ports, mapping table, table pruning)
  • Propose an application design which includes:

    • Network topology diagram
    • Sequence diagrams: packet event create mapping, packet event use mapping, packet event no mapping
    • Devise functional test for each sequence
    • Implement and verify application

IPv4/IPv6 Load Balancer

Problem Description

Implement traffic load balancer with FreeFlow. The load balancer will be written as a controller application running on OpenFlow controller. The target set and selection strategy must be configurable by the user.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. Additionally, the candidate is expectd to have basic proficiency in networking. The candidate will be expectd to familiarize themselves with the basic events of an OpenFlow application.</td>

Requirements & Goals

The deliverables for this project will be a load balancer application that supports IPv4 and IPv6 addresses, which is compatible with OpenFlow versions 1.0, 1.1, 1.2, 1.3, and 1.3.1. A user should be able to run this application on the FreeFlow controller regardless of the OpenFlow version that the network is running.

Procedures

  • Familiarize yourself with the Flowgrammable development environment
  • Familiarize yourself with the OpenFlow Flowgrammable stack
  • Develop an abstract model of a load balancer (targets, health detection, selection strategy, flow mappings, table pruning)
  • Propose an application design which includes:

    • Network topology diagram
    • Sequence diagrams: basic packet sequence reaching target, target health detection
    • Devise functional test for each sequence
    • Implement and verify application

OpenFlow Conformance Benchmarks

Stack Conformance Framework

Problem Description

A successful OpenFlow implementation needs to be conformant to the protocol specification. Having a test harness for conformance and would be able to help us pinpoint potential vulnerabilities in various stack implementations. Other than Freeflow, major 3rd party stacks should be included in the harness. OpenFlow versions 1.0 – 1.3.1 need to be covered.  The behavior of the implementations (switch or controller) should follow the specifications. In order to verify the level of conformance, generated test cases should follow a methodological approach that demonstrates complete coverage. Tests scripts need to be written for different 3rd party implementations.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. The candidate will be expected to familiarize themselves with several new language features present in C++11 as they are featured within the OpenFlow stack.

Requirements & Goals

The deliverable for this project will inclcude: interface development for integration of 3rd party OpenFlow stacks, and test development for extension of conformance tests.

Procedures

  • Familiarize yourself with the Flowgrammable development environment
  • Familiarize yourself with the OpenFlow Flowgrammable stack
  • Familiarize yoruself with the Flowgrammable conformance benchmark
  • Develop an abstract model of conformant behavior: message structure violation, state machine violation, application logic violation
  • Propose a design which includes:

    • 3rd party stacks to be encorporated
    • Interfaces necessary for each stack
    • Trace sketches to generate each violation
    • Implement and verify

OpenFlow Performance Benchmarks

Stack Performance Framework

Problem Description

A successful OpenFlow implementation should have good performance characteristics. A performance testing hardness would be able to help us evaluate the performance of various stack implementations. Other than Freeflow, major 3rd party stacks should be included in the harness. OpenFlow versions 1.0 – 1.3.1 need to be covered.  Traffic generation with different scenarios is required to drive the performance test. Tests scripts need to be written for different 3rd party implementations.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. The candidate will be expected to familiarize themselves with several new language features present in C++11 as they are featured within the OpenFlow stack. Additionally, the candidate will be 

Requirements & Goals

The deliverable for this project will inclcude: interface development for integration of 3rd party OpenFlow stacks, and test development for extension of performance tests.

Procedures

  • Familiarize yourself with the Flowgrammable development environment
  • Familiarize yourself with the OpenFlow Flowgrammable stack
  • Familiarize yoruself with the Flowgrammable performance benchmark
  • Develop an abstract model of design choices within a protocol stack
  • Propose a design which includes:

    • 3rd party stacks to be encorporated
    • Interfaces necessary for each stack
    • Measurements that will be possible given stack's implementation choices
    • Implement and verify

Classifier Benchmarks

Problem Description

Traditional networking devices implement packet classification techniques that are optimized for the device’s role in the network. What is the optimal packet classification technique for a SDN device, such as an Openflow switch,  which can be configured to serve in any role on the network? Flowgrammable can get the answer to this question by creating a tool that benchmarks a user specified flowtable against a variety of classification techniques.

With this tool a user will be able to test the performance of a variety of classification techniques against a user supplied flowtable configuration and matching packet trace. Some of the metrics we are interested in are in rate, out rate, latency , packets per second.

Qualifications

A successful candidate will be familiar with C++ and basic template programming. The candidate will be expected to familiarize themselves with several new language features present in C++11 as they are featured within the OpenFlow stack. Additionally, the candidate will have some familiarity with advanced algorithms such as prefix string matching in 1 and multiple dimensions.

Requirements & Goals

The deliverables for this project will be a classifier benchmark. This benchmark should have three inputs: packet trace with timings, classifier algorithm, and classifier state. The benchmark will be used to evaluate all three dimensions to measure classification algorithm performance udner SDN operating conditions.

Procedures

  • Familiarize yourself with the Flowgrammable development environment
  • Familiarize yourself with basics of single and multiple dimension string prefix matching, Network Algorithmics by George Varghese, chapters 10, 11, 12 are excellent starts
  • Familiarize yourself with research benchmarks: cbench, packet bench, np bench
  • Familiarize yourself with libpcap which will be used to read trace files
  • Familiarize yourself with the OpenFlow Flowgrammable stack
  • Propose a design which includes:

    • User defined types
    • Packet field extraction process
    • Generic classifier interface
    • Devise functional test for each classifier
    • Implement and verify application

MobileFlow

OpenFlow protocol does not provide native support for wireless interface so far. A wireless interface must be

adapted to a wireline port in order to be used in a current OpenFlow switch. MobileFlow is a project that designs

extension to current OpenFlow framework to provide wireless interface, specifically IEEE 802.11 (WiFi), with the

same level of abstraction as wireline interface. Implementation of MobileFlow based on OpenWRT and TP-Link wireless

access point is under development.

MobileFlow Controller Applications development

Problem Description

MobileFlow framework enables the OpenFlow controller to have much better information about the wireless system. In

addition, it gives the controller capability to control the wireless networks, e.g. dropping client, changing SSID,

etc. We would like to find wireless networks applications which could take advantage of MobileFlow, and implement

the corresponding OpenFlow controller applications.

Qualifications

A successful candidate will be familiar with C, network programming, IEEE 802.11 networks and have basic knowledge

of OpenFlow.

Requirement & Goals

Explore potential wireless network applications that can take advantage of MobileFlow framework and implement the

corresponding controllers.

Procedures

  • Familiarize yourself with MobileFlow design
  • Find potential wireless network applications
  • Familiarize yourself with one of the OpenFlow controller
  • Propose the controller application design and test plan
  • Implement the corresponding controller applications

Integrating MobileFlow to Flowsim

Problem Description

Flowsim is the OpenFlow data plane simulator developed by Flowgrammable. Up to now Flowsim only supports wireline

ports. We would like to integrate the design of MobileFlow into Flowsim.

Qualifications

A successful candidate will be familiar with C and JavaScript.

Requirement & Goals

Provide the extended Flowsim with support of IEEE 802.11 port

Procedures

  • Familiarize yourself with MobileFlow design
  • Familiarize yourself with Flowsim
  • Propose design of extension and test plan
  • Implement the extensions
  • Test and demo the extended Flowsim

Maple

Maple is a programming abstraction for writing SDN applications. With Maple users only have to write a packet handling function and never have to think about managing flow tables (unlike most controllers). Users write a function in Java (Maple supports Haskell as well) with the signature "Route onPacket(Packet p)" and then the Maple runtime system automatically manages flow tables so that the switch(es) behave as if they were running the user's function.

Maple programs declare their system state - similar to declaring a database schema - and the packet function can look up data in that state when processing functions and can update that state during packet processing. Maple runtime will keep track of the relationship between that state and the generated rules and will keep rules up to date automatically when state changes.

Maple has been implemented in Haskell and Java, and supports all the features explained in the Maple paper (and much more). The projects in this category are designed to demonstrate interesting applications and to flesh out various features of Maple.

Improved Maple Northbound API

Problem Description

Maple programs can declare state variables of several different types, including plain variables, sets, and maps. Maple currently includes a rudimentary REST server and JSON-based commands for reading and updating these state components from external programs. However, several important features are missing. (1) If the Maple program is composed of several sub-components, possibly independently authored, the names of the different state components could clash; hence we need some namespacing system. (2) Maple should provide a schema for the overall program, which could be consumed by a user to understand what operations are possible for a particular program. (3) The northbound API should allow users to structure their state updates into transactions. (4) Programmers should be able to control whether a state variables is externally visible or editable. (5) Maple-maintained state (built-in state) such as available switches, should be made available through the same northbound API as user-defined state.

Qualifications

A successful candidate will be familiar with both Haskell, Java. The candidates will need to gain knowledge of JSON, JSON schema, and JSON processing libraries in both Haskell and Java (eg. aeson and gson).

Requirements & Goals

The goal of this project is to improve the northbound API of Maple. By the end of the project, there should be north-bound API of Maple should (1) support fully-qualified state component names, (2) provide an API all that lists the schema of the overall program, (3) support methods to structure updates into transactions, (4) allow marking of state components to indicate external visibility and writability, (5) expose built-in state components as read-only state through the north-bound API.

Procedures

  • Familiarize yourself with Maple concepts via the paper and slides, and with the code base (TBD).
  • Evaluate related work, such as JSON schemas.
  • Iterate with the mentors on proposing and implementing solutions to the challenges in this project.

FlowSim-Maple Integration

Problem Description

Getting started writing SDN apps can be daunting, requiring familiarity in both data plane abstractions like OpenFlow, large, complex control systems, and network simulation tools. FlowSim substantially simplifies this picture by allowing users to configure an OpenFlow switch graphically in their browser and to see how their switch processes packets. To tackle realistic tasks, a controller is also needed. Moreover, to keep things simple, we need a controller that is nimble and easy to work with.

Qualifications

Openflow, Javascript (and related web skills), some Java, Docker (for cloud hosting of Maple)

Requirements & Goals

The goal of this project is to leverage FlowSim and Maple, a recent SDN programming system, to build a more complete online SDN learning environment. In particular, the project should allow users to view and edit simple Maple programs in their web browser, leveraging tools such as Ace to support browser-based code editing. In addition, the project will communicate with a cloud-based Maple service that runs a user’s Maple program and connect this Maple controller to a FlowSim switch, performing any necessary translation from the FlowSim API to the Maple API.

Procedures

  • Review FlowSim API and design and implement a layer to connect with an OpenFlow controller.
  • Design and implement a web frontend that allows to allow editing of maple controllers, leveraging tools such as Ace.
  • Invoke Maple cloud service to start maple controllers.
  • Design GUI to show the combined execution of packets through a FlowSim switch and interaction with the controller.