obsolete/backends/mock.py

# Copyright 2017-present Open Networking Foundation
#
# 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.
"""
Mock backend for testing purposes
"""

import logging
import os
import sys
from threading import Thread

from hexdump import hexdump
from scapy.all import Ether, IP, UDP, Dot1Q, sendp, sniff

# VERY IMPORTANT:
# Without the below hack, scapy will not properly receive VLAN
# header (see http://stackoverflow.com/questions/18994242/why-isnt-scapy-capturing-vlan-tag-information).
#
from scapy.all import conf, ETH_P_ALL
import pcap
conf.use_pcap = True
import scapy.arch.pcapdnet
assert conf.L2listen.__name__=='L2pcapListenSocket'

sys.path.insert(1, os.path.join(sys.path[0], '..'))

import loxi.of13 as ofp
from ofagent.utils import mac_str_to_tuple


class MockBackend(object):

    mfr_desc = "Ciena Corp."
    hw_desc = "mock"

    def __init__(self, store, in_out_iface=None, in_out_stag=None):
        self.store = store
        self.add_some_ports()
        self.in_out_iface = in_out_iface
        self.in_out_stag = in_out_stag
        self.agent = None
        self.in_out_receiver = None

    def set_agent(self, agent):
        self.agent = agent
        if self.in_out_iface is not None:
            self.in_out_receiver = InOutReceiver(self.in_out_iface, agent, self.in_out_stag)
            self.in_out_receiver.start()

    def stop(self):
        if self.in_out_receiver is not None:
            self.in_out_receiver.stop()

    def get_serial_num(self):
        return "DFG-4567-RTYU-789"

    def get_dp_desc(self):
        return "mock device"

    def add_some_ports(self):
        cap = ofp.OFPPF_1GB_FD | ofp.OFPPF_FIBER
        for pno, mac, nam, cur, adv, sup, spe in (
                (  1, '00:00:00:00:00:01', 'onu1', cap, cap, cap, ofp.OFPPF_1GB_FD),
                (  2, '00:00:00:00:00:02', 'onu2', cap, cap, cap, ofp.OFPPF_1GB_FD),
                (129, '00:00:00:00:00:81', 'olt',  cap, cap, cap, ofp.OFPPF_1GB_FD)
            ):
            port = ofp.common.port_desc(pno, mac_str_to_tuple(mac), nam,
                                        curr=cur, advertised=adv, supported=sup,
                                        curr_speed=spe, max_speed=spe)
            self.store.port_add(port)

    def packet_out(self, in_port, out_port, data):
        in_port = "CONTROLLER" if in_port == ofp.OFPP_CONTROLLER else in_port
        print "PACKET OUT (%s => %s): " % (in_port, out_port)
        hexdump(data)

        if self.in_out_iface is not None:

            try:
                # disect the packet
                pkt = Ether(data)

                # remove payload from Ether frame
                payload = pkt.payload
                payload_type = pkt.type
                pkt.remove_payload()

                # insert Dot1Q shim with vlan_id = out_port

                if self.in_out_stag is None:
                    ## WARNING -- This was changed from 0x88a8 to 0x8100 when
                    ## testing with the Intel XL710 quad 10GE boards.  The
                    ## XL710 does not support the TPID for the STAG.
                    ##
                    ## Long term, it should be changed back to 0x88a8!
                    ##
                    pkt.type = 0x8100
                    new_pkt = pkt / Dot1Q(vlan=out_port, type=payload_type) / payload

                else:
                    pkt.type = 0x8100
                    new_pkt = (
                            pkt /
                            Dot1Q(vlan=self.in_out_stag, type=0x8100) /
                            Dot1Q(vlan=out_port, type=payload_type) /
                            payload)

                # send out the packet
                sendp(new_pkt, iface=self.in_out_iface)

            except Exception, e:
                logging.exception("Could not parse packet-out data as scapy.Ether:\n")
                logging.error(hexdump(data, 'return'))


class InOutReceiver(Thread):

    def __init__(self, iface, agent, in_out_stag=None):
        Thread.__init__(self)
        self.iface = iface
        self.finished = False
        self.agent = agent
        self.in_out_stag = in_out_stag

    def run(self):
        # TODO this loop could be reconciled with the ofp Connection to become a
        # single select loop.
        self.sock = s = conf.L2listen(
            type=ETH_P_ALL,
            iface=self.iface,
            filter='inbound'
        )
        while not self.finished:
            try:
                sniffed = sniff(1, iface=self.iface, timeout=1, opened_socket=s)
                print 'Sniffer received %d packet(s)' % len(sniffed)
                for pkt in sniffed:
                    self.forward_packet(pkt)

            except Exception, e:
                logging.error("scapy.sniff error: %s" % e)

    def stop(self):
        """
        Signal the thread to exit and wait for it
        """
        assert not self.finished
        logging.debug("Stop sniffing on in-out channel")
        self.finished = True
        self.sock.close()
        self.join()

    def forward_packet(self, pkt):
        print "Received packet:"
        hexdump(str(pkt))
        pkt.show()

        try:
            assert isinstance(pkt, Ether)
            assert isinstance(pkt.getlayer(1), Dot1Q)
            dot1q = pkt.getlayer(1)
            assert isinstance(dot1q, Dot1Q)

            if self.in_out_stag is None:
                payload = dot1q.payload
                payload_type = dot1q.type
                pkt.remove_payload()

                pkt.type = payload_type
                new_pkt = pkt / payload
                in_port = dot1q.vlan

            else:
                if dot1q.vlan != self.in_out_stag:
                    print 'Dropping packet because outer tag %d does not match %d' % (
                        dot1q.vlan, self.in_out_stag)
                    return
                dot1q_inner = dot1q.getlayer(1)
                assert isinstance(dot1q_inner, Dot1Q)
                payload = dot1q_inner.payload
                payload_type = dot1q_inner.type
                pkt.remove_payload()

                pkt.type = payload_type
                new_pkt = pkt / payload
                in_port = dot1q_inner.vlan

            if self.agent is not None:
                self.agent.send_packet_in(str(new_pkt), in_port=in_port)
                print 'new packet forwarded to controller (with in_port=%d):' % in_port
                new_pkt.show()

        except Exception, e:
            logging.exception("Unexpected packet format received by InOutReceiver: %s" % e)
            logging.error(hexdump(str(pkt), 'return'))