Java Instructions.ExtensionInstructionWrapper方法代码示例

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
/**
 * Encodes a extension instruction.
 *
 * @param result json node that the instruction attributes are added to
 */
private void encodeExtension(ObjectNode result) {
    final Instructions.ExtensionInstructionWrapper extensionInstruction =
            (Instructions.ExtensionInstructionWrapper) instruction;

    DeviceId deviceId = extensionInstruction.deviceId();

    ServiceDirectory serviceDirectory = new DefaultServiceDirectory();
    DeviceService deviceService = serviceDirectory.get(DeviceService.class);
    Device device = deviceService.getDevice(deviceId);

    if (device.is(ExtensionTreatmentCodec.class)) {
        ExtensionTreatmentCodec treatmentCodec = device.as(ExtensionTreatmentCodec.class);
        ObjectNode node = treatmentCodec.encode(extensionInstruction.extensionInstruction(), context);
        result.set(InstructionCodec.EXTENSION, node);
    } else {
        log.warn("There is no codec to encode extension for device {}", deviceId.toString());
    }
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
@Override
public Instructions.ExtensionInstructionWrapper read(Kryo kryo, Input input,
                                                     Class<Instructions.ExtensionInstructionWrapper> type) {
    ExtensionTreatmentType exType = (ExtensionTreatmentType) kryo.readClassAndObject(input);
    DeviceId deviceId = (DeviceId) kryo.readClassAndObject(input);

    DriverService driverService = DefaultServiceDirectory.getService(DriverService.class);
    DriverHandler handler = new DefaultDriverHandler(
            new DefaultDriverData(driverService.getDriver(deviceId), deviceId));

    ExtensionTreatmentResolver resolver = handler.behaviour(ExtensionTreatmentResolver.class);
    ExtensionTreatment instruction = resolver.getExtensionInstruction(exType);

    byte[] bytes = (byte[]) kryo.readClassAndObject(input);

    instruction.deserialize(bytes);

    return Instructions.extension(instruction, deviceId);
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
private Bmv2Action getActionFromExtension(Instructions.ExtensionInstructionWrapper inst)
        throws Bmv2FlowRuleTranslatorException {

    ExtensionTreatment extTreatment = inst.extensionInstruction();

    if (extTreatment.type() == ExtensionTreatmentTypes.BMV2_ACTION.type()) {
        if (extTreatment instanceof Bmv2ExtensionTreatment) {
            return ((Bmv2ExtensionTreatment) extTreatment).action();
        } else {
            throw new Bmv2FlowRuleTranslatorException("Unable to decode treatment extension: " + extTreatment);
        }
    } else {
        throw new Bmv2FlowRuleTranslatorException("Unsupported treatment extension type: " + extTreatment.type());
    }
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
private List<OFAction> buildActions(TrafficTreatment treatment) {
    if (treatment == null) {
        return Collections.emptyList();
    }

    List<OFAction> actions = new LinkedList<>();
    for (Instruction i : treatment.allInstructions()) {
        switch (i.type()) {
            case L0MODIFICATION:
                actions.add(buildL0Modification(i));
                break;
            case L2MODIFICATION:
                actions.add(buildL2Modification(i));
                break;
            case L3MODIFICATION:
                actions.add(buildL3Modification(i));
                break;
            case OUTPUT:
                Instructions.OutputInstruction out =
                        (Instructions.OutputInstruction) i;
                OFActionOutput.Builder action = factory.actions().buildOutput()
                        .setPort(OFPort.of((int) out.port().toLong()));
                if (out.port().equals(PortNumber.CONTROLLER)) {
                    action.setMaxLen(OFPCML_NO_BUFFER);
                }
                actions.add(action.build());
                break;
            case GROUP:
                Instructions.GroupInstruction grp =
                        (Instructions.GroupInstruction) i;
                OFActionGroup.Builder actgrp = factory.actions().buildGroup()
                        .setGroup(OFGroup.of(grp.groupId().id()));
                actions.add(actgrp.build());
                break;
            case EXTENSION:
                Instructions.ExtensionInstructionWrapper wrapper =
                (Instructions.ExtensionInstructionWrapper) i;
                actions.add(buildExtensionAction(
                        wrapper.extensionInstruction(), wrapper.deviceId()));
                break;
            default:
                log.warn("Instruction type {} not yet implemented.", i.type());
        }
    }

    return actions;
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
@Override
public void write(Kryo kryo, Output output, Instructions.ExtensionInstructionWrapper object) {
    kryo.writeClassAndObject(output, object.extensionInstruction().type());
    kryo.writeClassAndObject(output, object.deviceId());
    kryo.writeClassAndObject(output, object.extensionInstruction().serialize());
}