
# 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.


"""
Test the role request message
"""
import struct
import unittest
import logging

import oftest
from oftest import config
import oftest.controller as controller
import ofp
import oftest.base_tests as base_tests

from oftest.testutils import *

def add_mod64(a, b):
    return (a + b) & (2**64-1)

def simple_role_request(test, role, gen=None, con=None):
    """
    Send a role request we expect to succeed
    """
    if con == None:
        con = test.controller
    request = ofp.message.role_request(role=role, generation_id=gen)
    response, _ = con.transact(request)
    test.assertTrue(isinstance(response, ofp.message.role_reply), "Expected a role reply")
    if role != ofp.OFPCR_ROLE_NOCHANGE:
        test.assertEquals(response.role, role)
    if gen != None:
        test.assertEquals(response.generation_id, gen)
    return response.role, response.generation_id

def failed_role_request(test, role, gen, code, con=None):
    """
    Send a role request we expect to fail
    """
    if con == None:
        con = test.controller
    request = ofp.message.role_request(role=role, generation_id=gen)
    response, _ = con.transact(request)
    test.assertIsInstance(response, ofp.message.role_request_failed_error_msg)
    test.assertEqual(response.code, code)

class RoleRequestNochange(base_tests.SimpleDataPlane):
    """
    Verify that we can query the switch for our current role and generation ID

    The role should default to OFPCR_ROLE_EQUAL.
    """
    def runTest(self):
        role, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)

        # Make sure the generation ID is still the same
        role, new_gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)
        self.assertEqual(new_gen, gen)

class RoleRequestEqualToSlave(base_tests.SimpleDataPlane):
    """
    Transition between equal and slave roles and back
    """
    def runTest(self):
        role, gen0 = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)

        # Unchanged generation ID
        role, gen1 = simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen0)

        # Back to equal
        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL)

        # Smallest greater generation ID
        role, gen2 = simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, add_mod64(gen1, 1))

        # Back to equal
        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL)

        # Largest greater generation ID
        role, gen3 = simple_role_request(self, ofp.OFPCR_ROLE_SLAVE,
                                         add_mod64(gen2, 2**63-1))

        # Back to equal
        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL)

        # Send least stale generation ID
        failed_role_request(self, ofp.OFPCR_ROLE_SLAVE,
                            add_mod64(gen3, -1),
                            ofp.OFPRRFC_STALE)

        # Check that our role is unchanged
        role, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)
        self.assertEqual(gen, gen3)

        # Send most stale generation ID
        failed_role_request(self, ofp.OFPCR_ROLE_SLAVE,
                            add_mod64(gen3, -(2**63)),
                            ofp.OFPRRFC_STALE)

        # Check that our role is unchanged
        role, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)
        self.assertEqual(gen, gen3)

class RoleRequestEqualToMaster(base_tests.SimpleDataPlane):
    """
    Transition between equal and master roles and back
    """
    def runTest(self):
        role, gen0 = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)

        # Unchanged generation ID
        role, gen1 = simple_role_request(self, ofp.OFPCR_ROLE_MASTER, gen0)

        # Back to equal
        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL)

        # Smallest greater generation ID
        role, gen2 = simple_role_request(self, ofp.OFPCR_ROLE_MASTER, add_mod64(gen1, 1))

        # Back to equal
        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL)

        # Largest greater generation ID
        role, gen3 = simple_role_request(self, ofp.OFPCR_ROLE_MASTER,
                                         add_mod64(gen2, 2**63-1))

        # Back to equal
        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL)

        # Send least stale generation ID
        failed_role_request(self, ofp.OFPCR_ROLE_MASTER,
                            add_mod64(gen3, -1),
                            ofp.OFPRRFC_STALE)

        # Check that our role is unchanged
        role, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)
        self.assertEqual(gen, gen3)

        # Send most stale generation ID
        failed_role_request(self, ofp.OFPCR_ROLE_MASTER,
                            add_mod64(gen3, -(2**63)),
                            ofp.OFPRRFC_STALE)

        # Check that our role is unchanged
        role, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)
        self.assertEqual(gen, gen3)

class RoleRequestSlaveToMaster(base_tests.SimpleDataPlane):
    """
    Transition between slave and master roles and back
    """
    def runTest(self):
        role, gen0 = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)

        # Initial transition to slave
        role, gen1 = simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen0)

        # Unchanged generation ID
        role, gen2 = simple_role_request(self, ofp.OFPCR_ROLE_MASTER, gen1)

        # Back to slave
        simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen2)

        # Smallest greater generation ID
        role, gen3 = simple_role_request(self, ofp.OFPCR_ROLE_MASTER,
                                         add_mod64(gen2, 1))

        # Back to slave
        simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen3)

        # Largest greater generation ID
        role, gen4 = simple_role_request(self, ofp.OFPCR_ROLE_MASTER,
                                         add_mod64(gen3, 2**63-1))

        # Back to slave
        simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen4)

        # Send least stale generation ID
        failed_role_request(self, ofp.OFPCR_ROLE_MASTER,
                            add_mod64(gen4, -1),
                            ofp.OFPRRFC_STALE)

        # Check that our role is unchanged
        role, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_SLAVE)
        self.assertEqual(gen, gen4)

        # Send most stale generation ID
        failed_role_request(self, ofp.OFPCR_ROLE_MASTER,
                            add_mod64(gen4, -(2**63)),
                            ofp.OFPRRFC_STALE)

        # Check that our role is unchanged
        role, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)
        self.assertEqual(role, ofp.OFPCR_ROLE_SLAVE)
        self.assertEqual(gen, gen4)

class RolePermissions(base_tests.SimpleDataPlane):
    """
    Verify that a slave connection cannot modify switch state, but
    a master or equal can.
    """
    def runTest(self):
        delete_all_flows(self.controller)
        self.verify_permission(True)

        role, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)

        simple_role_request(self, ofp.OFPCR_ROLE_MASTER, gen)
        self.verify_permission(True)

        simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen)
        self.verify_permission(False)

        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL)
        self.verify_permission(True)

    def verify_permission(self, perm):
        self.controller.message_send(
            ofp.message.packet_out(buffer_id=ofp.OFP_NO_BUFFER))

        self.controller.message_send(
            ofp.message.flow_delete(
                buffer_id=ofp.OFP_NO_BUFFER,
                out_port=ofp.OFPP_ANY,
                out_group=ofp.OFPG_ANY))

        self.controller.message_send(
            ofp.message.group_mod(
                command=ofp.OFPGC_DELETE,
                group_id=ofp.OFPG_ALL))

        # TODO OFPT_PORT_MOD
        # TODO OFPT_TABLE_MOD

        do_barrier(self.controller)

        err_count = 0
        while self.controller.packets:
            msg = self.controller.packets.pop(0)[0]
            if msg.type == ofp.OFPT_ERROR:
                self.assertEquals(msg.err_type, ofp.OFPET_BAD_REQUEST)
                self.assertEquals(msg.code, ofp.OFPBRC_IS_SLAVE)
                err_count += 1

        if perm:
            self.assertEquals(err_count, 0, "Expected no errors")
        else:
            self.assertEquals(err_count, 3, "Expected errors for each message")

class SlaveNoPacketIn(base_tests.SimpleDataPlane):
    """
    Verify that slave connections do not receive OFPT_PACKET_IN messages but other roles do.
    """
    def runTest(self):
        delete_all_flows(self.controller)
        ingress_port, = openflow_ports(1)
        pkt = str(simple_tcp_packet())

        logging.info("Inserting table-miss flow sending all packets to controller")
        request = ofp.message.flow_add(
            table_id=test_param_get("table", 0),
            instructions=[
                ofp.instruction.apply_actions(
                    actions=[
                        ofp.action.output(
                            port=ofp.OFPP_CONTROLLER,
                            max_len=ofp.OFPCML_NO_BUFFER)])],
            buffer_id=ofp.OFP_NO_BUFFER,
            priority=0)
        self.controller.message_send(request)
        do_barrier(self.controller)

        _, gen = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE)

        simple_role_request(self, ofp.OFPCR_ROLE_MASTER, gen)
        self.dataplane.send(ingress_port, pkt)
        verify_packet_in(self, pkt, ingress_port, ofp.OFPR_NO_MATCH)

        simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen)
        self.dataplane.send(ingress_port, pkt)
        verify_no_packet_in(self, pkt, ingress_port)

        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL, gen)
        self.dataplane.send(ingress_port, pkt)
        verify_packet_in(self, pkt, ingress_port, ofp.OFPR_NO_MATCH)

@disabled
class RoleSwitch(unittest.TestCase):
    """
    Verify that when a connection becomes a master the existing master is
    downgraded to slave.

    Requires the switch to attempt to connect in parallel to ports 6653
    and 6753 on the configured IP.
    """

    def setUp(self):
        host = config["controller_host"]
        self.controllers = [
            controller.Controller(host=host,port=6653),
            controller.Controller(host=host,port=6753)
        ]

    def runTest(self):
        # Connect and handshake with both controllers
        for con in self.controllers:
            con.start()
            if not con.connect():
                raise AssertionError("failed to connect controller %s" % str(con))
            reply, _ = con.transact(ofp.message.features_request())
            self.assertTrue(isinstance(reply, ofp.message.features_reply))

        # Assert initial role and get generation IDs
        role, gen0 = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE, con=self.controllers[0])
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)
        role, gen1 = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE, con=self.controllers[1])
        self.assertEqual(role, ofp.OFPCR_ROLE_EQUAL)

        # Initial role assignment: controller 0 is master, controller 1 is slave
        simple_role_request(self, ofp.OFPCR_ROLE_MASTER, gen0, con=self.controllers[0])
        simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen1, con=self.controllers[1])
        self.verify_role(self.controllers[0], ofp.OFPCR_ROLE_MASTER)
        self.verify_role(self.controllers[1], ofp.OFPCR_ROLE_SLAVE)

        # Controller 1 requests master
        # Controller 0 becomes slave
        simple_role_request(self, ofp.OFPCR_ROLE_MASTER, gen1, con=self.controllers[1])
        self.verify_role(self.controllers[0], ofp.OFPCR_ROLE_SLAVE)
        self.verify_role(self.controllers[1], ofp.OFPCR_ROLE_MASTER)

        # Controller 0 requests master
        # Controller 1 becomes slave
        simple_role_request(self, ofp.OFPCR_ROLE_MASTER, gen0, con=self.controllers[0])
        self.verify_role(self.controllers[0], ofp.OFPCR_ROLE_MASTER)
        self.verify_role(self.controllers[1], ofp.OFPCR_ROLE_SLAVE)

        # Controller 1 requests equal
        # Controller 0 remains master
        simple_role_request(self, ofp.OFPCR_ROLE_EQUAL, gen1, con=self.controllers[1])
        self.verify_role(self.controllers[0], ofp.OFPCR_ROLE_MASTER)
        self.verify_role(self.controllers[1], ofp.OFPCR_ROLE_EQUAL)

        # Both controllers request slave
        simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen0, con=self.controllers[0])
        simple_role_request(self, ofp.OFPCR_ROLE_SLAVE, gen1, con=self.controllers[1])
        self.verify_role(self.controllers[0], ofp.OFPCR_ROLE_SLAVE)
        self.verify_role(self.controllers[1], ofp.OFPCR_ROLE_SLAVE)

    def verify_role(self, con, role):
        rcv_role, _ = simple_role_request(self, ofp.OFPCR_ROLE_NOCHANGE, con=con)
        self.assertEqual(rcv_role, role)

    def tearDown(self):
        for con in self.controllers:
            con.shutdown()