= Architecture = The design of this project draws heavily from !FlowVisor, but does so in a way to fit back into Floodlight's modular model. Many components are named after the !FlowVisor components on which their functions are based. === Internal links === [#comp Components][[BR]] [#ov Overview][[BR]] [#det Component details][[BR]] [#i Containers][[BR]] [#ii FVProxyProvider][[BR]] [#iii FlowVisor service][[BR]] [#iv Message Handlers][[BR]] ---- == Components == #comp The main components are: * Containers for configurations: * Slices * The !FlowMap * Configuration files - one for !FlowVisor policies and another for module configurations * FVProxyProvider - A module providing the core event handler * The !FlowVisor service - The main event handler * Message handler components: * the FVClassifier, which handles messages to/from switches * the FVSlicer, which handles messages to/from modules ---- == Overview == #ov The following figure illustrates a high-level view of the implementation as it applies to a connection from one switch (s1): [[Image(FL-slicer.png)]] * Each switch is associated with a FVClassifier. * For each slice that the switch belongs to FVClassifier initializes an FVSlicer. * Each slice specifies a module that it is able to isolate. Some slices may not be associated with any modules (and vice versa) ---- == Component details == #det === Containers === #i The JSON-formatted configuration file used by this implementation is nearly identical to the one used by !FlowVisor. The Floodlight version of this file has a "modules" field specifying which modules should be kept in what slice. By default, Floodlight will search for a file named 'config.json' in src/main/resources/ . Although !FlowVisor would store the contents of the config file in a database at startup, this project assumes that there is no persistent storage. Instead of a database, a few classes are used to keep this information available: * Slice : configurations of individual slices * FVConfUtil : !FlowSpace contents, !FlowMap ---- === FVProxyProvider === #ii This module is analogous to the [http://www.openflowhub.org/display/floodlightcontroller/FloodlightProvider FloodlightProvider], and provides similar main functionalities of handling switch connections, turning messages into events that modules can subscribe to, and dealing with the details of dispatching messages to the modules. In addition to these functions, FVProxyProvider also reads in the !FlowVisor configurations from file, and initializes the container structures necessary for the message handlers to determine how messages should be processed. '''Implementation :''' net.floodlightcontroller.core.FVProxyProvider.java '''Dependencies''' * FVConfUtil : reading !FlowVisor configs, initialization/access to container structures * !FlowVisor : connection and event handling/dispatch * config.json : !FlowVisor slice policies, flow rules '''Initializes :''' The !FlowVisor service ---- === The !FlowVisor service === #iii The !FlowVisor service is derived from Floodlight's Controller class, a component that implements the services that !FloodlightProvider provides. The !FlowVisor service initializes switch-side message handlers (FVClassifiers) for each switch connection, and dispatches messages as events to subscribing modules according to message type and slice policy. '''Implementation :''' net.floodlightcontroller.core.internal.!FlowVisor.java '''Dependencies''' * Controller : base class * FVSlicer : per-message slice policy information '''Initializes :''' FVClassifier (per switch connection) Because of their same logical roles, the !FlowVisor/FVProxyProvider pair are interchangeable with the Controller/!FloodlightProvider pair, allowing this version of Floodlight to be easily switched between "!FlowVisor" and "normal" modes of operation through the [http://www.openflowhub.org/display/floodlightcontroller/Module+loading+system module loading system]'s configuration file. ---- === Message handlers === #iv The message handlers prevent conflicting messages from being sent out to the switches by modifying !OpenFlow messages and controlling how the !FlowVisor service dispatches messages to the modules. The classes and logic responsible for processing the messages are taken from !FlowVisor, hence there are many analogues between this implementation and !FlowVisor's message processing chain. Two major packages are largely borrowed from !FlowVisor: * org.flowvisor.message* : Implementations of class and action specific message processing for OFMessages * net.floodlightcontroller.flowspace* : !FlowMap and !FlowSpace manipulation === FVClassifier === FVClassifier is derived from Floodlight's OFSwitchImpl class. A FVClassifier instance is associated with one switch, and is responsible for initializing one FVSlicer per slice that the switch is part of, processing messages to/from the switch according to policies in the !FlowMap, and sending out messages for the modules and the !FlowVisor service. '''Implementation :''' org.flowvisor.classifier.FVClassifier.java '''Dependencies''' * OFSwitchImpl : base class * org.flowvisor.message* : Extended versions of OFMessage classes with interfaces for message processing * FVMessageConverter : translation of messages between OFMessage and !FlowVisor equivalents in org.flowvisor.message* '''Initializes :''' FVSlicer (per slice) === FVSlicer === Each FVSlicer enforces slice policies for one slice onto messages to/from the modules. The two main functions of FVSlicer are the processing of outbound messages and providing the !FlowVisor service with the slice policy that is used to restrict the list of modules that a given message can be dispatched to. The current implementation supplies a list of 'blacklisted' modules that should be ignored during message dispatch. '''Implementation :''' org.flowvisor.slicer.FVSlicer.java '''Dependencies''' * Slice : slice configuration information * org.flowvisor.message* : Extended versions of OFMessage classes with interfaces for message processing * FVMessageConverter : translation of messages between OFMessage and !FlowVisor equivalents in org.flowvisor.message* ----