Add Oplink attenuation extension and channel power drivers.

Change-Id: I2558595b03cbb6cc58237dc48b8a03e83357fe1f

@@ -61,7 +61,8 @@ public final class ExtensionTreatmentType {
         NICIRA_ENCAP_ETH_SRC(121),
         NICIRA_ENCAP_ETH_DST(122),
         NICIRA_ENCAP_ETH_TYPE(123),
-        BMV2_ACTION(128);
+        BMV2_ACTION(128),
+        OPLINK_ATTENUATION(130);
 
         private ExtensionTreatmentType type;
 

@@ -32,6 +32,7 @@ import org.onosproject.driver.extensions.NiciraSetNshSpi;
 import org.onosproject.driver.extensions.NiciraSetTunnelDst;
 import org.onosproject.driver.extensions.OfdpaMatchVlanVid;
 import org.onosproject.driver.extensions.OfdpaSetVlanVid;
+import org.onosproject.driver.extensions.OplinkAttenuation;
 import org.onosproject.driver.extensions.codec.MoveExtensionTreatmentCodec;
 import org.onosproject.driver.extensions.codec.NiciraMatchNshSiCodec;
 import org.onosproject.driver.extensions.codec.NiciraMatchNshSpiCodec;
@@ -43,6 +44,7 @@ import org.onosproject.driver.extensions.codec.NiciraSetNshSpiCodec;
 import org.onosproject.driver.extensions.codec.NiciraSetTunnelDstCodec;
 import org.onosproject.driver.extensions.codec.OfdpaMatchVlanVidCodec;
 import org.onosproject.driver.extensions.codec.OfdpaSetVlanVidCodec;
+import org.onosproject.driver.extensions.codec.OplinkAttenuationCodec;
 import org.slf4j.Logger;
 
 import static org.slf4j.LoggerFactory.getLogger;
@@ -71,6 +73,7 @@ public class DefaultCodecRegister {
         codecService.registerCodec(NiciraSetNshContextHeader.class, new NiciraSetNshContextHeaderCodec());
         codecService.registerCodec(OfdpaMatchVlanVid.class, new OfdpaMatchVlanVidCodec());
         codecService.registerCodec(OfdpaSetVlanVid.class, new OfdpaSetVlanVidCodec());
+        codecService.registerCodec(OplinkAttenuation.class, new OplinkAttenuationCodec());
         log.info("Registered default driver codecs.");
     }
 
@@ -87,6 +90,7 @@ public class DefaultCodecRegister {
         codecService.unregisterCodec(NiciraSetNshContextHeader.class);
         codecService.unregisterCodec(OfdpaMatchVlanVid.class);
         codecService.unregisterCodec(OfdpaSetVlanVid.class);
+        codecService.unregisterCodec(OplinkAttenuation.class);
         log.info("Unregistered default driver codecs.");
     }
 }

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * 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.onosproject.driver.extensions;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.Maps;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.net.flow.AbstractExtension;
+import org.onosproject.net.flow.instructions.ExtensionTreatment;
+import org.onosproject.net.flow.instructions.ExtensionTreatmentType;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Instruction for Oplink channel attenuation.
+ */
+public class OplinkAttenuation extends AbstractExtension implements ExtensionTreatment {
+    private static final String KEY_ATT = "attenuation";
+
+    private int attenuation;
+
+    private final KryoNamespace appKryo = new KryoNamespace.Builder()
+            .register(Map.class)
+            .build("OplinkAttenuation");
+
+    /**
+     * Creates new attenuation instruction.
+     * @param attenuation attenuation value
+     */
+    public OplinkAttenuation(int attenuation) {
+        this.attenuation = attenuation;
+    }
+
+    /**
+     * Gets the attenuation value.
+     * @return attenuation
+     */
+    public int getAttenuation() {
+        return attenuation;
+    }
+
+    /**
+     * Modify the attenuation value.
+     * @param attenuation new attenuation value
+     */
+    public void setAttenuation(int attenuation) {
+        this.attenuation = attenuation;
+    }
+
+    @Override
+    public ExtensionTreatmentType type() {
+        return ExtensionTreatmentType.ExtensionTreatmentTypes.OPLINK_ATTENUATION.type();
+    }
+
+    @Override
+    public byte[] serialize() {
+        Map<String, Object> values = Maps.newHashMap();
+        values.put(KEY_ATT, attenuation);
+        return appKryo.serialize(values);
+    }
+
+    @Override
+    public void deserialize(byte[] data) {
+        Map<String, Object> values = appKryo.deserialize(data);
+        attenuation = (int) values.get(KEY_ATT);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(attenuation);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof OplinkAttenuation) {
+            OplinkAttenuation that = (OplinkAttenuation) obj;
+            return Objects.equals(attenuation, that.attenuation);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add(KEY_ATT, attenuation)
+                .toString();
+    }
+}

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * 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.onosproject.driver.extensions;
+
+import org.onosproject.net.driver.AbstractHandlerBehaviour;
+import org.onosproject.net.flow.instructions.ExtensionTreatment;
+import org.onosproject.net.flow.instructions.ExtensionTreatmentType;
+import org.onosproject.openflow.controller.ExtensionTreatmentInterpreter;
+import org.projectfloodlight.openflow.protocol.OFActionType;
+import org.projectfloodlight.openflow.protocol.OFFactory;
+import org.projectfloodlight.openflow.protocol.action.OFAction;
+import org.projectfloodlight.openflow.protocol.action.OFActionExperimenter;
+import org.projectfloodlight.openflow.protocol.action.OFActionOplinkAtt;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxm;
+import org.projectfloodlight.openflow.types.U32;
+
+/**
+ * Interpreter for Oplink OpenFlow treatment extensions.
+ */
+public class OplinkExtensionTreatmentInterpreter extends AbstractHandlerBehaviour
+        implements ExtensionTreatmentInterpreter {
+
+    private static final long ATTENUATION_EXP = 0xff000088L;
+
+    @Override
+    public boolean supported(ExtensionTreatmentType extensionTreatmentType) {
+        if (extensionTreatmentType.equals(
+                ExtensionTreatmentType.ExtensionTreatmentTypes.OPLINK_ATTENUATION.type())) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public OFAction mapInstruction(OFFactory factory, ExtensionTreatment extensionTreatment) {
+        ExtensionTreatmentType type = extensionTreatment.type();
+        if (type.equals(ExtensionTreatmentType.ExtensionTreatmentTypes.OPLINK_ATTENUATION.type())) {
+            int att = ((OplinkAttenuation) extensionTreatment).getAttenuation();
+            return factory.actions().oplinkAtt(factory.oxms().ochSigatt(U32.ofRaw(att)));
+        }
+        return null;
+    }
+
+    @Override
+    public ExtensionTreatment mapAction(OFAction action) throws UnsupportedOperationException {
+        if (action.getType().equals(OFActionType.EXPERIMENTER)) {
+            OFActionExperimenter actionExp = (OFActionExperimenter) action;
+            if (actionExp.getExperimenter() == ATTENUATION_EXP) {
+                OFActionOplinkAtt actionAtt = (OFActionOplinkAtt) action;
+                return new OplinkAttenuation(((OFOxm<U32>) actionAtt.getField()).getValue().getRaw());
+            }
+        }
+        return null;
+    }
+}

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * 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.onosproject.driver.extensions.codec;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.driver.extensions.OplinkAttenuation;
+
+import static org.onlab.util.Tools.nullIsIllegal;
+
+/**
+ * JSON Codec for OplinkAttenuation class.
+ */
+public class OplinkAttenuationCodec extends JsonCodec<OplinkAttenuation> {
+    private static final String ATTENUATION = "attenuation";
+    private static final String MISSING_ATT = "Missing value for \"attenuation\"";
+
+    @Override
+    public OplinkAttenuation decode(ObjectNode json, CodecContext context) {
+        if (json == null || !json.isObject()) {
+            return null;
+        }
+        String att = nullIsIllegal(json.get(ATTENUATION), MISSING_ATT).asText();
+        return new OplinkAttenuation(Integer.valueOf(att));
+    }
+}

+package org.onosproject.driver.optical.extensions;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.onlab.osgi.DefaultServiceDirectory;
+import org.onlab.osgi.ServiceDirectory;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.CodecService;
+import org.onosproject.codec.ExtensionTreatmentCodec;
+import org.onosproject.driver.extensions.OplinkAttenuation;
+import org.onosproject.net.driver.AbstractHandlerBehaviour;
+import org.onosproject.net.flow.instructions.ExtensionTreatment;
+import org.onosproject.net.flow.instructions.ExtensionTreatmentType;
+
+import static org.onlab.util.Tools.nullIsIllegal;
+
+/**
+ * Codec for Oplink extensions.
+ */
+public class OplinkExtensionTreatmentCodec extends AbstractHandlerBehaviour
+        implements ExtensionTreatmentCodec {
+
+    private static final String TYPE = "type";
+    private static final String MISSING_TYPE = "Missing extension type";
+    private static final String UNSUPPORTED_TYPE = "Extension type is not supported: ";
+
+    @Override
+    public ExtensionTreatment decode(ObjectNode objectNode, CodecContext context) {
+        if (objectNode == null || !objectNode.isObject()) {
+            return null;
+        }
+
+        int typeInt = nullIsIllegal(objectNode.get(TYPE), MISSING_TYPE).asInt();
+        ExtensionTreatmentType type = new ExtensionTreatmentType(typeInt);
+
+        if (type.equals(ExtensionTreatmentType.ExtensionTreatmentTypes.OPLINK_ATTENUATION.type())) {
+            return decodeTreatment(objectNode, context, OplinkAttenuation.class);
+        } else {
+            throw new UnsupportedOperationException(UNSUPPORTED_TYPE + type.toString());
+        }
+    }
+
+    private <T extends ExtensionTreatment> ExtensionTreatment decodeTreatment(
+            ObjectNode objectNode, CodecContext context, Class<T> entityClass) {
+        if (context == null) {
+            ServiceDirectory serviceDirectory = new DefaultServiceDirectory();
+            return serviceDirectory.get(CodecService.class).getCodec(entityClass).decode(objectNode, null);
+        } else {
+            return context.codec(entityClass).decode(objectNode, context);
+        }
+    }
+}

+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.
+ */
+/**
+ * Implementations of extension behaviours for optical devices.
+ */
+package org.onosproject.driver.optical.extensions;

@@ -41,6 +41,7 @@ import org.onosproject.net.device.DefaultPortDescription;
 import org.onosproject.net.device.DeviceService;
 import org.onosproject.net.device.PortDescription;
 import org.onosproject.net.link.DefaultLinkDescription;
+import org.onosproject.net.link.LinkService;
 import org.onosproject.net.optical.OpticalAnnotations;
 import org.onosproject.openflow.controller.Dpid;
 import org.onosproject.openflow.controller.OpenFlowOpticalSwitch;
@@ -190,17 +191,19 @@ public class OplinkRoadm extends AbstractOpenFlowSwitch implements OpenFlowOptic
     public final void sendMsg(OFMessage m) {
         List<OFMessage> messages = new ArrayList<>();
         messages.add(m);
+
         if (m.getType() == OFType.STATS_REQUEST) {
             OFStatsRequest sr = (OFStatsRequest) m;
             log.debug("OPLK ROADM rebuilding stats request type {}", sr.getStatsType());
             switch (sr.getStatsType()) {
                 case PORT:
-                    //replace with Oplink experiment stats message to get the port current power
+                    //add Oplink experiment stats message to get the port's current power
                     OFOplinkPortPowerRequest powerRequest = this.factory().buildOplinkPortPowerRequest()
                             .setXid(sr.getXid())
                             .setFlags(sr.getFlags())
                             .build();
                     messages.add(powerRequest);
+                    // add experiment message to get adjacent ports
                     OFExpPortAdjacencyRequest adjacencyRequest = this.factory().buildExpPortAdjacencyRequest()
                             .setXid(sr.getXid())
                             .setFlags(sr.getFlags())
@@ -335,7 +338,7 @@ public class OplinkRoadm extends AbstractOpenFlowSwitch implements OpenFlowOptic
 
     private void addLink(PortNumber portNumber, OplinkPortAdjacency neighbor) {
         ConnectPoint dst = new ConnectPoint(handler().data().deviceId(), portNumber);
-        ConnectPoint src = new ConnectPoint(neighbor.getDeviceId(), neighbor.portNumber);
+        ConnectPoint src = new ConnectPoint(neighbor.getDeviceId(), neighbor.getPort());
         OpticalAdjacencyLinkService adService =
                 this.handler().get(OpticalAdjacencyLinkService.class);
         adService.linkDetected(new DefaultLinkDescription(src, dst, Link.Type.OPTICAL));
@@ -344,9 +347,13 @@ public class OplinkRoadm extends AbstractOpenFlowSwitch implements OpenFlowOptic
     // Remove incoming link with port if there are any.
     private void removeLink(PortNumber portNumber) {
         ConnectPoint dst = new ConnectPoint(handler().data().deviceId(), portNumber);
-        OpticalAdjacencyLinkService adService =
-                this.handler().get(OpticalAdjacencyLinkService.class);
-        adService.linksVanished(dst);
+        // Check so only incoming links are removed
+        Set<Link> links = this.handler().get(LinkService.class).getIngressLinks(dst);
+        if (!links.isEmpty()) {
+            OpticalAdjacencyLinkService adService =
+                    this.handler().get(OpticalAdjacencyLinkService.class);
+            adService.linksVanished(dst);
+        }
     }
 
     private class OplinkPortAdjacency {

@@ -58,6 +58,10 @@
                    impl="org.onosproject.net.optical.DefaultOpticalDevice"/>
         <behaviour api="org.onosproject.net.behaviour.PowerConfig"
                    impl="org.onosproject.driver.optical.power.OplinkRoadmPowerConfig"/>
+        <behaviour api="org.onosproject.codec.ExtensionTreatmentCodec"
+                   impl="org.onosproject.driver.optical.extensions.OplinkExtensionTreatmentCodec"/>
+        <behaviour api="org.onosproject.openflow.controller.ExtensionTreatmentInterpreter"
+                   impl="org.onosproject.driver.extensions.OplinkExtensionTreatmentInterpreter"/>
     </driver>
 
 </drivers>