IslUtils.java

Go to the documentation of this file.

/* Copyright 2018 Telstra Open Source
 *
 *   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.
 */

package org.openkilda.testing.tools;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasProperty;
import static org.hamcrest.core.Every.everyItem;

import org.openkilda.messaging.info.event.IslChangeType;
import org.openkilda.messaging.info.event.IslInfoData;
import org.openkilda.messaging.info.event.PathNode;
import org.openkilda.testing.model.topology.TopologyDefinition;
import org.openkilda.testing.model.topology.TopologyDefinition.ASwitch;
import org.openkilda.testing.model.topology.TopologyDefinition.Isl;
import org.openkilda.testing.service.aswitch.ASwitchService;
import org.openkilda.testing.service.aswitch.model.ASwitchFlow;
import org.openkilda.testing.service.northbound.NorthboundService;

import net.jodah.failsafe.Failsafe;
import net.jodah.failsafe.RetryPolicy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Component
public class IslUtils {

    @Autowired
    private NorthboundService northbound;

    @Autowired
    private ASwitchService aswitchService;

    public void waitForIslStatus(List<Isl> isls, String expectedStatus, RetryPolicy retryPolicy) {
        IslChangeType expectedIslState = IslChangeType.valueOf(expectedStatus);

        List<IslInfoData> actualIsl = Failsafe.with(retryPolicy
                .retryIf(states -> ((List<IslInfoData>) states).stream()
                        .map(IslInfoData::getState)
                        .anyMatch(state -> !state.equals(expectedIslState))))
                .get(() -> {
                    List<IslInfoData> allLinks = northbound.getAllLinks();
                    return isls.stream().map(isl -> getIslInfo(allLinks, isl)).collect(Collectors.toList());
                });

        assertThat(actualIsl, everyItem(hasProperty("state", equalTo(expectedIslState))));
    }

    public void waitForIslStatus(List<Isl> isls, String expectedStatus) {
        waitForIslStatus(isls, expectedStatus, retryPolicy());
    }

    public IslInfoData getIslInfo(Isl isl) {
        return getIslInfo(northbound.getAllLinks(), isl);
    }

    public IslInfoData getIslInfo(List<IslInfoData> islsInfo, Isl isl) {
        return islsInfo.stream().filter(link -> {
            PathNode src = link.getPath().get(0);
            PathNode dst = link.getPath().get(1);
            return src.getPortNo() == isl.getSrcPort() && dst.getPortNo() == isl.getDstPort()
                    && src.getSwitchId().equals(isl.getSrcSwitch().getDpId())
                    && dst.getSwitchId().equals(isl.getDstSwitch().getDpId());
        }).findFirst().get();
    }

    public Isl reverseIsl(Isl isl) {
        ASwitch reversedAsw = null;
        if (isl.getAswitch() != null) {
            reversedAsw = ASwitch.factory(isl.getAswitch().getOutPort(), isl.getAswitch().getInPort());
        }
        return Isl.factory(isl.getDstSwitch(), isl.getDstPort(), isl.getSrcSwitch(),
                isl.getSrcPort(), isl.getMaxBandwidth(), reversedAsw);
    }

    public TopologyDefinition.Isl replug(TopologyDefinition.Isl srcIsl, boolean replugSource,
                                         TopologyDefinition.Isl dstIsl, boolean plugIntoSource) {
        ASwitch srcASwitch = srcIsl.getAswitch();
        ASwitch dstASwitch = dstIsl.getAswitch();
        //unplug
        List<Integer> portsToUnplug = Collections.singletonList(
                replugSource ? srcASwitch.getInPort() : srcASwitch.getOutPort());
        aswitchService.portsDown(portsToUnplug);

        //change flow on aSwitch
        //delete old flow
        aswitchService.removeFlows(Arrays.asList(
                new ASwitchFlow(srcASwitch.getInPort(), srcASwitch.getOutPort()),
                new ASwitchFlow(srcASwitch.getOutPort(), srcASwitch.getInPort())));
        //create new flow
        ASwitchFlow aswFlowForward = new ASwitchFlow(srcASwitch.getInPort(),
                plugIntoSource ? dstASwitch.getInPort() : dstASwitch.getOutPort());
        ASwitchFlow aswFlowReverse = new ASwitchFlow(aswFlowForward.getOutPort(), aswFlowForward.getInPort());
        aswitchService.addFlows(Arrays.asList(aswFlowForward, aswFlowReverse));

        //plug back
        aswitchService.portsUp(portsToUnplug);

        return TopologyDefinition.Isl.factory(
                replugSource ? (plugIntoSource ? dstIsl.getSrcSwitch() : dstIsl.getDstSwitch()) : srcIsl.getSrcSwitch(),
                replugSource ? (plugIntoSource ? dstIsl.getSrcPort() : dstIsl.getDstPort()) : srcIsl.getSrcPort(),
                replugSource ? srcIsl.getDstSwitch() : (plugIntoSource ? dstIsl.getSrcSwitch() : dstIsl.getDstSwitch()),
                replugSource ? srcIsl.getDstPort() : (plugIntoSource ? dstIsl.getSrcPort() : dstIsl.getDstPort()),
                0,
                new TopologyDefinition.ASwitch(
                        replugSource ? (plugIntoSource ? dstIsl.getAswitch().getInPort() :
                                dstIsl.getAswitch().getOutPort()) : srcIsl.getAswitch().getInPort(),
                        replugSource ? srcIsl.getAswitch().getOutPort() :
                                (plugIntoSource ? dstIsl.getAswitch().getInPort() : dstIsl.getAswitch().getOutPort())
                ));
    }

    private RetryPolicy retryPolicy() {
        return new RetryPolicy()
                .withDelay(3, TimeUnit.SECONDS)
                .withMaxRetries(15);
    }
}