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,10 +347,14 @@ 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);
+        // 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 {
         private DeviceId deviceId;

@@ -16,14 +16,31 @@
 
 package org.onosproject.driver.optical.power;
 
+import java.util.List;
 import java.util.Optional;
 
+import org.onosproject.driver.extensions.OplinkAttenuation;
+import org.onosproject.net.OchSignal;
 import org.onosproject.net.driver.AbstractHandlerBehaviour;
 import org.onosproject.net.Direction;
 import org.onosproject.net.Port;
 import org.onosproject.net.PortNumber;
 import org.onosproject.net.behaviour.PowerConfig;
 import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.flow.DefaultFlowRule;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.FlowEntry;
+import org.onosproject.net.flow.FlowRule;
+import org.onosproject.net.flow.FlowRuleService;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.criteria.OchSignalCriterion;
+import org.onosproject.net.flow.criteria.PortCriterion;
+import org.onosproject.net.flow.instructions.ExtensionTreatment;
+import org.onosproject.net.flow.instructions.ExtensionTreatmentType;
+import org.onosproject.net.flow.instructions.Instruction;
+import org.onosproject.net.flow.instructions.Instructions;
 import org.onosproject.net.optical.OpticalAnnotations;
 import org.onosproject.openflow.controller.Dpid;
 import org.onosproject.openflow.controller.OpenFlowController;
@@ -40,9 +57,28 @@ import org.slf4j.LoggerFactory;
  */
 
 public class OplinkRoadmPowerConfig extends AbstractHandlerBehaviour
-                                    implements PowerConfig<Direction> {
+                                    implements PowerConfig<Object> {
+
     protected final Logger log = LoggerFactory.getLogger(getClass());
 
+    // Component type
+    private enum Type {
+        NONE,
+        PORT,
+        CHANNEL
+    }
+
+    // Get the type if component is valid
+    private Type getType(Object component) {
+        if (component == null || component instanceof Direction) {
+            return Type.PORT;
+        } else if (component instanceof OchSignal) {
+            return Type.CHANNEL;
+        } else {
+            return Type.NONE;
+        }
+    }
+
     private OpenFlowSwitch getOpenFlowDevice() {
         final OpenFlowController controller = this.handler().get(OpenFlowController.class);
         final Dpid dpid = Dpid.dpid(this.data().deviceId().uri());
@@ -54,41 +90,177 @@ public class OplinkRoadmPowerConfig extends AbstractHandlerBehaviour
         }
     }
 
+    // Find matching flow on device
+    private FlowEntry findFlow(PortNumber portNum, OchSignal och) {
+        FlowRuleService service = this.handler().get(FlowRuleService.class);
+        Iterable<FlowEntry> flowEntries = service.getFlowEntries(this.data().deviceId());
+
+        // Return first matching flow
+        for (FlowEntry entry : flowEntries) {
+            TrafficSelector selector = entry.selector();
+            OchSignalCriterion entrySigid =
+                    (OchSignalCriterion) selector.getCriterion(Criterion.Type.OCH_SIGID);
+            if (entrySigid != null && och.equals(entrySigid.lambda())) {
+                PortCriterion entryPort =
+                        (PortCriterion) selector.getCriterion(Criterion.Type.IN_PORT);
+                if (entryPort != null && portNum.equals(entryPort.port())) {
+                    return entry;
+                }
+            }
+        }
+        log.warn("No matching flow found");
+        return null;
+    }
+
     @Override
-    public Optional<Long> getTargetPower(PortNumber portNum, Direction component) {
+    public Optional<Long> getTargetPower(PortNumber portNum, Object component) {
+        Long returnVal = null;
+        // Check if switch is connected, otherwise do not return value in store,
+        // which is obsolete.
+        if (getOpenFlowDevice() != null) {
+            switch (getType(component)) {
+                case PORT:
                     // Will be implemented in the future.
-        return Optional.empty();
+                    break;
+                case CHANNEL:
+                    returnVal = getChannelAttenuation(portNum, (OchSignal) component);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return Optional.ofNullable(returnVal);
     }
 
     @Override
-    public Optional<Long> currentPower(PortNumber portNum, Direction component) {
+    public Optional<Long> currentPower(PortNumber portNum, Object component) {
         Long returnVal = null;
         // Check if switch is connected, otherwise do not return value in store,
         // which is obsolete.
         if (getOpenFlowDevice() != null) {
+            switch (getType(component)) {
+                case PORT:
+                    returnVal = getCurrentPortPower(portNum);
+                    break;
+                case CHANNEL:
+                    returnVal = getCurrentChannelPower(portNum, (OchSignal) component);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return Optional.ofNullable(returnVal);
+    }
+
+    @Override
+    public void setTargetPower(PortNumber portNum, Object component, long power) {
+        if (getOpenFlowDevice() != null) {
+            switch (getType(component)) {
+                case PORT:
+                    setTargetPortPower(portNum, power);
+                    break;
+                case CHANNEL:
+                    setChannelAttenuation(portNum, (OchSignal) component, power);
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            log.warn("OpenFlow handshaker driver not found or device is not connected");
+        }
+    }
+
+    private Long getChannelAttenuation(PortNumber portNum, OchSignal och) {
+        FlowEntry flowEntry = findFlow(portNum, och);
+        if (flowEntry != null) {
+            List<Instruction> instructions = flowEntry.treatment().allInstructions();
+            for (Instruction ins : instructions) {
+                if (ins.type() == Instruction.Type.EXTENSION) {
+                    ExtensionTreatment ext = ((Instructions.ExtensionInstructionWrapper) ins).extensionInstruction();
+                    if (ext.type() == ExtensionTreatmentType.ExtensionTreatmentTypes.OPLINK_ATTENUATION.type()) {
+                        return (long) ((OplinkAttenuation) ext).getAttenuation();
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    private Long getCurrentPortPower(PortNumber portNum) {
         DeviceService deviceService = this.handler().get(DeviceService.class);
         Port port = deviceService.getPort(this.data().deviceId(), portNum);
         if (port != null) {
             String currentPower = port.annotations().value(OpticalAnnotations.CURRENT_POWER);
             if (currentPower != null) {
-                    returnVal = Long.valueOf(currentPower);
+                return Long.valueOf(currentPower);
             }
         }
+        return null;
     }
-        return Optional.ofNullable(returnVal);
+
+    private Long getCurrentChannelPower(PortNumber portNum, OchSignal och) {
+        FlowEntry flowEntry = findFlow(portNum, och);
+        if (flowEntry != null) {
+            // TODO put somewhere else if possible
+            // We put channel power in packets
+            return flowEntry.packets();
+        }
+        return null;
     }
 
-    @Override
-    public void setTargetPower(PortNumber portNum, Direction component, long power) {
+    private void setTargetPortPower(PortNumber portNum, long power) {
         OpenFlowSwitch device = getOpenFlowDevice();
-        if (device != null) {
         device.sendMsg(device.factory().buildOplinkPortPowerSet()
                 .setXid(0)
                 .setPort((int) portNum.toLong())
                 .setPowerValue((int) power)
                 .build());
+    }
+
+    private void setChannelAttenuation(PortNumber portNum, OchSignal och, long power) {
+        FlowEntry flowEntry = findFlow(portNum, och);
+        if (flowEntry != null) {
+            List<Instruction> instructions = flowEntry.treatment().allInstructions();
+            for (Instruction ins : instructions) {
+                if (ins.type() == Instruction.Type.EXTENSION) {
+                    ExtensionTreatment ext = ((Instructions.ExtensionInstructionWrapper) ins).extensionInstruction();
+                    if (ext.type() == ExtensionTreatmentType.ExtensionTreatmentTypes.OPLINK_ATTENUATION.type()) {
+                        ((OplinkAttenuation) ext).setAttenuation((int) power);
+                        FlowRuleService service = this.handler().get(FlowRuleService.class);
+                        service.applyFlowRules(flowEntry);
+                        return;
+                    }
+                }
+            }
+            addAttenuation(flowEntry, power);
         } else {
-            log.warn("OpenFlow handshaker driver not found or device is not connected");
+            log.warn("Target channel power not set");
         }
     }
+
+    // Replace flow with new flow containing Oplink attenuation extension instruction. Also resets
+    // metrics.
+    private void addAttenuation(FlowEntry flowEntry, long power) {
+        FlowRule.Builder flowBuilder = new DefaultFlowRule.Builder();
+        flowBuilder.withCookie(flowEntry.id().value());
+        flowBuilder.withPriority(flowEntry.priority());
+        flowBuilder.forDevice(flowEntry.deviceId());
+        flowBuilder.forTable(flowEntry.tableId());
+        if (flowEntry.isPermanent()) {
+            flowBuilder.makePermanent();
+        } else {
+            flowBuilder.makeTemporary(flowEntry.timeout());
+        }
+
+        flowBuilder.withSelector(flowEntry.selector());
+
+        // Copy original instructions and add attenuation instruction
+        TrafficTreatment.Builder treatmentBuilder = DefaultTrafficTreatment.builder();
+        flowEntry.treatment().allInstructions().forEach(ins -> treatmentBuilder.add(ins));
+        treatmentBuilder.add(Instructions.extension(new OplinkAttenuation((int) power), this.data().deviceId()));
+        flowBuilder.withTreatment(treatmentBuilder.build());
+
+        FlowRuleService service = this.handler().get(FlowRuleService.class);
+        service.applyFlowRules(flowBuilder.build());
+    }
 }

@@ -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>