diff --git a/floodlight.py b/floodlight.py
new file mode 100644
index 0000000..eb6b6fb
--- /dev/null
+++ b/floodlight.py
@@ -0,0 +1,441 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+##
+# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
+# This file is part of openmano
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: nfvlabs@tid.es
+##
+
+'''
+Implement the plugging for floodligth openflow controller
+It creates the class OF_conn to create dataplane connections
+with static rules based on packet destination MAC address
+'''
+
+__author__="Pablo Montes, Alfonso Tierno"
+__date__ ="$28-oct-2014 12:07:15$"
+
+
+import json
+import requests
+import logging
+
+class OF_conn():
+    ''' Openflow Connector for Floodlight.
+         No MAC learning is used
+        version 0.9 or 1.X is autodetected
+        version 1.X is in progress, not finished!!!
+    '''
+    def __init__(self, params):
+        ''' Constructor. 
+            params is a dictionay with the following keys:
+                of_dpid:     DPID to use for this controller
+                of_ip:       controller IP address
+                of_port:     controller TCP port
+                of_version:  version, can be "0.9" or "1.X". By default it is autodetected
+                of_debug:    debug level for logging. Default to ERROR
+                other keys are ignored
+            Raise an exception if same parameter is missing or wrong
+        '''
+        #check params
+        if "of_ip" not in params or params["of_ip"]==None or "of_port" not in params or params["of_port"]==None:
+            raise ValueError("IP address and port must be provided")
+
+        self.name = "Floodlight"
+        self.dpid = str(params["of_dpid"])
+        self.url = "http://%s:%s" %( str(params["of_ip"]), str(params["of_port"]) )
+
+        self.pp2ofi={}  # From Physical Port to OpenFlow Index
+        self.ofi2pp={}  # From OpenFlow Index to Physical Port
+        self.headers = {'content-type':'application/json', 'Accept':'application/json'}
+        self.version= None
+        self.logger = logging.getLogger('vim.OF.FL')
+        self.logger.setLevel( getattr(logging, params.get("of_debug", "ERROR") ) )
+        self._set_version(params.get("of_version") )
+    
+    def _set_version(self, version):
+        '''set up a version of the controller.
+         Depending on the version it fills the self.ver_names with the naming used in this version
+        '''
+        #static version names
+        if version==None:
+            self.version= None
+        elif version=="0.9":
+            self.version= version
+            self.name = "Floodlightv0.9"
+            self.ver_names={
+                "dpid":         "dpid",
+                "URLmodifier":  "staticflowentrypusher",
+                "destmac":      "dst-mac",
+                "vlanid":       "vlan-id",
+                "inport":       "ingress-port",
+                "setvlan":      "set-vlan-id",
+                "stripvlan":    "strip-vlan",
+            }
+        elif version[0]=="1" : #version 1.X
+            self.version= version
+            self.name = "Floodlightv1.X"
+            self.ver_names={
+                "dpid":         "switchDPID",
+                "URLmodifier":  "staticflowpusher",
+                "destmac":      "eth_dst",
+                "vlanid":       "eth_vlan_vid",
+                "inport":       "in_port",
+                "setvlan":      "set_vlan_vid",
+                "stripvlan":    "strip_vlan",
+            }
+        else:
+            raise ValueError("Invalid version for floodlight controller")
+            
+    def get_of_switches(self):
+        ''' Obtain a a list of switches or DPID detected by this controller
+            Return
+                >=0, list:      list length, and a list where each element a tuple pair (DPID, IP address)
+                <0, text_error: if fails
+        '''  
+        try:
+            of_response = requests.get(self.url+"/wm/core/controller/switches/json", headers=self.headers)
+            error_text = "Openflow response %d: %s" % (of_response.status_code, of_response.text)
+            if of_response.status_code != 200:
+                self.logger.warning("get_of_switches " + error_text)
+                return -1 , error_text
+            self.logger.debug("get_of_switches " + error_text)
+            info = of_response.json()
+            if type(info) != list and type(info) != tuple:
+                self.logger.error("get_of_switches. Unexpected response not a list %s", str(type(info)))
+                return -1, "Unexpected response, not a list. Wrong version?"
+            if len(info)==0:
+                return 0, info
+            #autodiscover version
+            if self.version == None:
+                if 'dpid' in info[0] and 'inetAddress' in info[0]:
+                    self._set_version("0.9")
+                elif 'switchDPID' in info[0] and 'inetAddress' in info[0]:
+                    self._set_version("1.X")
+                else:
+                    self.logger.error("get_of_switches. Unexpected response, not found 'dpid' or 'switchDPID' field: %s", str(info[0]))
+                    return -1, "Unexpected response, not found 'dpid' or 'switchDPID' field. Wrong version?"
+            
+            switch_list=[]
+            for switch in info:
+                switch_list.append( (switch[ self.ver_names["dpid"] ], switch['inetAddress']) )
+            return len(switch_list), switch_list
+        except (requests.exceptions.RequestException, ValueError) as e:
+            #ValueError in the case that JSON can not be decoded
+            error_text = type(e).__name__ + ": " + str(e)
+            self.logger.error("get_of_switches " + error_text)
+            return -1, error_text
+
+    def get_of_rules(self, translate_of_ports=True):
+        ''' Obtain the rules inserted at openflow controller
+            Params:
+                translate_of_ports: if True it translates ports from openflow index to physical switch name
+            Return:
+                0, dict if ok: with the rule name as key and value is another dictionary with the following content:
+                    priority: rule priority
+                    name:         rule name (present also as the master dict key)
+                    ingress_port: match input port of the rule
+                    dst_mac:      match destination mac address of the rule, can be missing or None if not apply
+                    vlan_id:      match vlan tag of the rule, can be missing or None if not apply
+                    actions:      list of actions, composed by a pair tuples:
+                        (vlan, None/int): for stripping/setting a vlan tag
+                        (out, port):      send to this port 
+                    switch:       DPID, all 
+                -1, text_error if fails
+        '''   
+        
+        #get translation, autodiscover version
+        if len(self.ofi2pp) == 0:
+            r,c = self.obtain_port_correspondence()
+            if r<0:
+                return r,c
+        #get rules
+        try:
+            of_response = requests.get(self.url+"/wm/%s/list/%s/json" %(self.ver_names["URLmodifier"], self.dpid),
+                                        headers=self.headers)
+            error_text = "Openflow response %d: %s" % (of_response.status_code, of_response.text)
+            if of_response.status_code != 200:
+                self.logger.warning("get_of_rules " + error_text)
+                return -1 , error_text
+            self.logger.debug("get_of_rules " + error_text)
+            info = of_response.json()
+            if type(info) != dict:
+                self.logger.error("get_of_rules. Unexpected response not a dict %s", str(type(info)))
+                return -1, "Unexpected response, not a dict. Wrong version?"
+            rule_dict={}
+            for switch,switch_info in info.iteritems():
+                if switch_info == None:
+                    continue
+                if str(switch) != self.dpid:
+                    continue
+                for name,details in switch_info.iteritems():
+                    rule = {}
+                    rule["switch"] = str(switch)
+                    #rule["active"] = "true"
+                    rule["priority"] = int(details["priority"])
+                    if self.version[0]=="0":
+                        if translate_of_ports:
+                            rule["ingress_port"] = self.ofi2pp[ details["match"]["inputPort"] ] 
+                        else:
+                            rule["ingress_port"] = str(details["match"]["inputPort"])
+                        dst_mac = details["match"]["dataLayerDestination"]
+                        if dst_mac != "00:00:00:00:00:00":
+                            rule["dst_mac"] = dst_mac
+                        vlan = details["match"]["dataLayerVirtualLan"]
+                        if vlan != -1:
+                            rule["vlan_id"] = vlan
+                        actionlist=[]
+                        for action in details["actions"]:
+                            if action["type"]=="OUTPUT":
+                                if translate_of_ports:
+                                    port = self.ofi2pp[ action["port"] ]
+                                else:
+                                    port = action["port"]
+                                actionlist.append( ("out", port) )
+                            elif action["type"]=="STRIP_VLAN":
+                                actionlist.append( ("vlan",None) )
+                            elif action["type"]=="SET_VLAN_ID":
+                                actionlist.append( ("vlan", action["virtualLanIdentifier"]) )
+                            else:
+                                actionlist.append( (action["type"], str(action) ))
+                                self.logger.warning("get_of_rules() Unknown action in rule %s: %s", rule["name"], str(action))
+                            rule["actions"] = actionlist
+                    elif self.version[0]=="1":
+                        if translate_of_ports:
+                            rule["ingress_port"] = self.ofi2pp[ details["match"]["in_port"] ]
+                        else:
+                            rule["ingress_port"] = details["match"]["in_port"]
+                        if "eth_dst" in details["match"]:
+                            dst_mac = details["match"]["eth_dst"]
+                            if dst_mac != "00:00:00:00:00:00":
+                                rule["dst_mac"] = dst_mac
+                        if "eth_vlan_vid" in details["match"]:
+                            vlan = int(details["match"]["eth_vlan_vid"],16) & 0xFFF
+                            rule["vlan_id"] = str(vlan)
+                        actionlist=[]
+                        for action in details["instructions"]["instruction_apply_actions"]:
+                            if action=="output":
+                                if translate_of_ports:
+                                    port = self.ofi2pp[ details["instructions"]["instruction_apply_actions"]["output"] ]
+                                else:
+                                    port = details["instructions"]["instruction_apply_actions"]["output"]
+                                actionlist.append( ("out",port) )
+                            elif action=="strip_vlan":
+                                actionlist.append( ("vlan",None) )
+                            elif action=="set_vlan_vid":
+                                actionlist.append( ("vlan", details["instructions"]["instruction_apply_actions"]["set_vlan_vid"]) )
+                            else:
+                                self.logger.error("get_of_rules Unknown action in rule %s: %s", rule["name"], str(action))
+                                #actionlist.append( (action, str(details["instructions"]["instruction_apply_actions"]) ))
+                    rule_dict[str(name)] = rule
+            return 0, rule_dict
+        except (requests.exceptions.RequestException, ValueError) as e:
+            #ValueError in the case that JSON can not be decoded
+            error_text = type(e).__name__ + ": " + str(e)
+            self.logger.error("get_of_rules " + error_text)
+            return -1, error_text
+
+    def obtain_port_correspondence(self):
+        '''Obtain the correspondence between physical and openflow port names
+        return:
+             0, dictionary: with physical name as key, openflow name as value
+            -1, error_text: if fails
+        '''
+        try:
+            of_response = requests.get(self.url+"/wm/core/controller/switches/json", headers=self.headers)
+            #print vim_response.status_code
+            error_text = "Openflow response %d: %s" % (of_response.status_code, of_response.text)
+            if of_response.status_code != 200:
+                self.logger.warning("obtain_port_correspondence " + error_text)
+                return -1 , error_text
+            self.logger.debug("obtain_port_correspondence " + error_text)
+            info = of_response.json()
+            
+            if type(info) != list and type(info) != tuple:
+                return -1, "unexpected openflow response, not a list. Wrong version?"
+            
+            index = -1
+            if len(info)>0:
+                #autodiscover version
+                if self.version == None:
+                    if 'dpid' in info[0] and 'ports' in info[0]:
+                        self._set_version("0.9")
+                    elif 'switchDPID' in info[0]:
+                        self._set_version("1.X")
+                    else:
+                        return -1, "unexpected openflow response, Wrong version?"
+
+            for i in range(0,len(info)):
+                if info[i][ self.ver_names["dpid"] ] == self.dpid:
+                    index = i
+                    break
+            if index == -1:
+                text = "DPID '"+self.dpid+"' not present in controller "+self.url
+                #print self.name, ": get_of_controller_info ERROR", text 
+                return -1, text
+            else:
+                if self.version[0]=="0":
+                    ports = info[index]["ports"]
+                else: #version 1.X
+                    of_response = requests.get(self.url+"/wm/core/switch/%s/port-desc/json" %self.dpid, headers=self.headers)
+                    #print vim_response.status_code
+                    error_text = "Openflow response %d: %s" % (of_response.status_code, of_response.text)
+                    if of_response.status_code != 200:
+                        self.logger.warning("obtain_port_correspondence " + error_text)
+                        return -1 , error_text
+                    self.logger.debug("obtain_port_correspondence " + error_text)
+                    info = of_response.json()
+                    if type(info) != dict:
+                        return -1, "unexpected openflow port-desc response, not a dict. Wrong version?"
+                    if "portDesc" not in info:
+                        return -1, "unexpected openflow port-desc response, 'portDesc' not found. Wrong version?"
+                    if type(info["portDesc"]) != list and type(info["portDesc"]) != tuple:
+                        return -1, "unexpected openflow port-desc response at 'portDesc', not a list. Wrong version?"
+                    ports = info["portDesc"]
+                for port in ports:
+                    self.pp2ofi[ str(port["name"]) ] = str(port["portNumber"] )
+                    self.ofi2pp[ port["portNumber"]] = str(port["name"]) 
+            #print self.name, ": get_of_controller_info ports:", self.pp2ofi
+            return 0, self.pp2ofi
+        except (requests.exceptions.RequestException, ValueError) as e:
+            #ValueError in the case that JSON can not be decoded
+            error_text = type(e).__name__ + ": " + str(e)
+            self.logger.error("obtain_port_correspondence " + error_text)
+            return -1, error_text
+            
+    def del_flow(self, flow_name):
+        ''' Delete an existing rule
+            Params: flow_name, this is the rule name
+            Return
+                0, None if ok
+                -1, text_error if fails
+        '''           
+        #autodiscover version
+        if self.version == None:
+            r,c = self.get_of_switches()
+            if r<0:
+                return r,c
+            elif r==0:
+                return -1, "No dpid found "
+        try:
+            of_response = requests.delete(self.url+"/wm/%s/json" % self.ver_names["URLmodifier"],
+                                headers=self.headers, data='{"switch":"%s","name":"%s"}' %(self.dpid, flow_name)
+                            )
+            error_text = "Openflow response %d: %s" % (of_response.status_code, of_response.text)
+            if of_response.status_code != 200:
+                self.logger.warning("del_flow " + error_text)
+                return -1 , error_text
+            self.logger.debug("del_flow OK " + error_text)
+            return 0, None
+
+        except requests.exceptions.RequestException as e:
+            error_text = type(e).__name__ + ": " + str(e)
+            self.logger.error("del_flow " + error_text)
+            return -1, error_text
+
+    def new_flow(self, data):
+        ''' Insert a new static rule
+            Params: data: dictionary with the following content:
+                priority:     rule priority
+                name:         rule name
+                ingress_port: match input port of the rule
+                dst_mac:      match destination mac address of the rule, missing or None if not apply
+                vlan_id:      match vlan tag of the rule, missing or None if not apply
+                actions:      list of actions, composed by a pair tuples with these posibilities:
+                    ('vlan', None/int): for stripping/setting a vlan tag
+                    ('out', port):      send to this port
+            Return
+                0, None if ok
+                -1, text_error if fails
+        '''   
+        #get translation, autodiscover version
+        if len(self.pp2ofi) == 0:
+            r,c = self.obtain_port_correspondence()
+            if r<0:
+                return r,c
+        try:
+            #We have to build the data for the floodlight call from the generic data
+            sdata = {'active': "true", "name":data["name"]}
+            if data.get("priority"):
+                sdata["priority"] = str(data["priority"])
+            if data.get("vlan_id"):
+                sdata[ self.ver_names["vlanid"]  ] = data["vlan_id"]
+            if data.get("dst_mac"):
+                sdata[  self.ver_names["destmac"]  ] = data["dst_mac"]
+            sdata['switch'] = self.dpid
+            if not data['ingress_port'] in self.pp2ofi:
+                error_text = 'Error. Port '+data['ingress_port']+' is not present in the switch'
+                self.logger.warning("new_flow " + error_text)
+                return -1, error_text
+            
+            sdata[  self.ver_names["inport"]  ] = self.pp2ofi[data['ingress_port']]
+            sdata['actions'] = ""
+
+            for action in data['actions']:
+                if len(sdata['actions']) > 0:
+                    sdata['actions'] +=  ','
+                if action[0] == "vlan":
+                    if action[1]==None:
+                        sdata['actions'] += self.ver_names["stripvlan"]
+                    else:
+                        sdata['actions'] += self.ver_names["setvlan"] + "=" + str(action[1])
+                elif action[0] == 'out':
+                    sdata['actions'] += "output=" + self.pp2ofi[ action[1] ]
+
+
+            of_response = requests.post(self.url+"/wm/%s/json" % self.ver_names["URLmodifier"],
+                                headers=self.headers, data=json.dumps(sdata) )
+            error_text = "Openflow response %d: %s" % (of_response.status_code, of_response.text)
+            if of_response.status_code != 200:
+                self.logger.warning("new_flow " + error_text)
+                return -1 , error_text
+            self.logger.debug("new_flow OK" + error_text)
+            return 0, None
+
+        except requests.exceptions.RequestException as e:
+            error_text = type(e).__name__ + ": " + str(e)
+            self.logger.error("new_flow " + error_text)
+            return -1, error_text
+
+    def clear_all_flows(self):
+        ''' Delete all existing rules
+            Return:
+                0, None if ok
+                -1, text_error if fails
+        '''           
+        #autodiscover version
+        if self.version == None:
+            r,c = self.get_of_switches()
+            if r<0:
+                return r,c
+            elif r==0: #empty
+                return 0, None
+        try:
+            url = self.url+"/wm/%s/clear/%s/json" % (self.ver_names["URLmodifier"], self.dpid)
+            of_response = requests.get(url )
+            error_text = "Openflow response %d: %s" % (of_response.status_code, of_response.text)
+            if of_response.status_code < 200 or of_response.status_code >= 300:
+                self.logger.warning("clear_all_flows " + error_text)
+                return -1 , error_text
+            self.logger.debug("clear_all_flows OK " + error_text)
+            return 0, None
+        except requests.exceptions.RequestException as e:
+            error_text = type(e).__name__ + ": " + str(e)
+            self.logger.error("clear_all_flows " + error_text)
+            return -1, error_text