홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
sangho
Committed by Gerrit Code Review
5afd02ad 1 parent 8995ac58

ONOS-894 : Implemented GroupProvider 

Change-Id: I2755abd433921a420ad545fcf6fef61e90a8b89f
Inline Side-by-side
Showing 7 changed files with 1102 additions and 1 deletions
......@@ -149,7 +149,7 @@
<bundle>mvn:org.onosproject/onos-of-provider-device/@ONOS-VERSION</bundle>
<bundle>mvn:org.onosproject/onos-of-provider-packet/@ONOS-VERSION</bundle>
<bundle>mvn:org.onosproject/onos-of-provider-flow/@ONOS-VERSION</bundle>
<bundle>mvn:org.onosproject/onos-of-provider-group/@ONOS-VERSION</bundle>
</feature>
<feature name="onos-app-tvue" version="@FEATURE-VERSION"
......
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Copyright 2015 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.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.onosproject</groupId>
<artifactId>onos-of-providers</artifactId>
<version>1.1.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<artifactId>onos-of-provider-group</artifactId>
<packaging>bundle</packaging>
<description>ONOS OpenFlow protocol group provider</description>
</project>
\ No newline at end of file
/*
* Copyright 2015 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.provider.of.group.impl;
import com.google.common.collect.Lists;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.core.GroupId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.flow.DefaultTrafficTreatment;
import org.onosproject.net.flow.TrafficTreatment;
import org.onosproject.net.group.DefaultGroupBucket;
import org.onosproject.net.group.GroupBucket;
import org.onosproject.net.group.GroupBuckets;
import org.projectfloodlight.openflow.protocol.OFBucket;
import org.projectfloodlight.openflow.protocol.OFGroupType;
import org.projectfloodlight.openflow.protocol.action.OFAction;
import org.projectfloodlight.openflow.protocol.action.OFActionCircuit;
import org.projectfloodlight.openflow.protocol.action.OFActionCopyTtlIn;
import org.projectfloodlight.openflow.protocol.action.OFActionCopyTtlOut;
import org.projectfloodlight.openflow.protocol.action.OFActionDecMplsTtl;
import org.projectfloodlight.openflow.protocol.action.OFActionDecNwTtl;
import org.projectfloodlight.openflow.protocol.action.OFActionExperimenter;
import org.projectfloodlight.openflow.protocol.action.OFActionOutput;
import org.projectfloodlight.openflow.protocol.action.OFActionPopMpls;
import org.projectfloodlight.openflow.protocol.action.OFActionPushMpls;
import org.projectfloodlight.openflow.protocol.action.OFActionSetDlDst;
import org.projectfloodlight.openflow.protocol.action.OFActionSetDlSrc;
import org.projectfloodlight.openflow.protocol.action.OFActionSetField;
import org.projectfloodlight.openflow.protocol.action.OFActionSetNwDst;
import org.projectfloodlight.openflow.protocol.action.OFActionSetNwSrc;
import org.projectfloodlight.openflow.protocol.action.OFActionSetVlanPcp;
import org.projectfloodlight.openflow.protocol.action.OFActionSetVlanVid;
import org.projectfloodlight.openflow.protocol.oxm.OFOxm;
import org.projectfloodlight.openflow.protocol.oxm.OFOxmOchSigidBasic;
import org.projectfloodlight.openflow.types.IPv4Address;
import org.projectfloodlight.openflow.types.OFVlanVidMatch;
import org.projectfloodlight.openflow.types.U32;
import org.projectfloodlight.openflow.types.VlanPcp;
import org.slf4j.Logger;
import java.util.List;
import static org.slf4j.LoggerFactory.getLogger;
/*
* Builder for GroupBucketEntry.
*/
public class GroupBucketEntryBuilder {
private List<OFBucket> ofBuckets;
private OFGroupType type;
private final Logger log = getLogger(getClass());
/**
* Creates a builder.
*
* @param ofBuckets list of OFBucket
* @param type Group type
*/
public GroupBucketEntryBuilder(List<OFBucket> ofBuckets, OFGroupType type) {
this.ofBuckets = ofBuckets;
this.type = type;
}
/**
* Builds a GroupBuckets.
*
* @return GroupBuckets object, a list of GroupBuck
*/
public GroupBuckets build() {
List<GroupBucket> bucketList = Lists.newArrayList();
for (OFBucket bucket: ofBuckets) {
TrafficTreatment treatment = buildTreatment(bucket.getActions());
// TODO: Use GroupBucketEntry
GroupBucket groupBucket = null;
switch (type) {
case INDIRECT:
groupBucket =
DefaultGroupBucket.createIndirectGroupBucket(treatment);
break;
case SELECT:
groupBucket =
DefaultGroupBucket.createSelectGroupBucket(treatment);
break;
case FF:
PortNumber port =
PortNumber.portNumber(bucket.getWatchPort().getPortNumber());
GroupId groupId =
new DefaultGroupId(bucket.getWatchGroup().getGroupNumber());
groupBucket =
DefaultGroupBucket.createFailoverGroupBucket(treatment,
port, groupId);
break;
default:
log.error("Unsupported Group type : {}", type);
}
if (groupBucket != null) {
bucketList.add(groupBucket);
}
}
return new GroupBuckets(bucketList);
}
private TrafficTreatment buildTreatment(List<OFAction> actions) {
TrafficTreatment.Builder builder = DefaultTrafficTreatment.builder();
// If this is a drop rule
if (actions.size() == 0) {
builder.drop();
return builder.build();
}
for (OFAction act : actions) {
switch (act.getType()) {
case OUTPUT:
OFActionOutput out = (OFActionOutput) act;
builder.setOutput(
PortNumber.portNumber(out.getPort().getPortNumber()));
break;
case SET_VLAN_VID:
OFActionSetVlanVid vlan = (OFActionSetVlanVid) act;
builder.setVlanId(VlanId.vlanId(vlan.getVlanVid().getVlan()));
break;
case SET_VLAN_PCP:
OFActionSetVlanPcp pcp = (OFActionSetVlanPcp) act;
builder.setVlanPcp(pcp.getVlanPcp().getValue());
break;
case SET_DL_DST:
OFActionSetDlDst dldst = (OFActionSetDlDst) act;
builder.setEthDst(
MacAddress.valueOf(dldst.getDlAddr().getLong()));
break;
case SET_DL_SRC:
OFActionSetDlSrc dlsrc = (OFActionSetDlSrc) act;
builder.setEthSrc(
MacAddress.valueOf(dlsrc.getDlAddr().getLong()));
break;
case SET_NW_DST:
OFActionSetNwDst nwdst = (OFActionSetNwDst) act;
IPv4Address di = nwdst.getNwAddr();
builder.setIpDst(Ip4Address.valueOf(di.getInt()));
break;
case SET_NW_SRC:
OFActionSetNwSrc nwsrc = (OFActionSetNwSrc) act;
IPv4Address si = nwsrc.getNwAddr();
builder.setIpSrc(Ip4Address.valueOf(si.getInt()));
break;
case EXPERIMENTER:
OFActionExperimenter exp = (OFActionExperimenter) act;
if (exp.getExperimenter() == 0x80005A06 ||
exp.getExperimenter() == 0x748771) {
OFActionCircuit ct = (OFActionCircuit) exp;
builder.setLambda(((OFOxmOchSigidBasic) ct.getField()).getValue().getChannelNumber());
} else {
log.warn("Unsupported OFActionExperimenter {}", exp.getExperimenter());
}
break;
case SET_FIELD:
OFActionSetField setField = (OFActionSetField) act;
handleSetField(builder, setField.getField());
break;
case POP_MPLS:
OFActionPopMpls popMpls = (OFActionPopMpls) act;
builder.popMpls((short) popMpls.getEthertype().getValue());
break;
case PUSH_MPLS:
OFActionPushMpls pushMpls = (OFActionPushMpls) act;
builder.pushMpls();
break;
case COPY_TTL_IN:
OFActionCopyTtlIn copyTtlIn = (OFActionCopyTtlIn) act;
builder.copyTtlIn();
break;
case COPY_TTL_OUT:
OFActionCopyTtlOut copyTtlOut = (OFActionCopyTtlOut) act;
builder.copyTtlOut();
break;
case DEC_MPLS_TTL:
OFActionDecMplsTtl decMplsTtl = (OFActionDecMplsTtl) act;
builder.decMplsTtl();
break;
case DEC_NW_TTL:
OFActionDecNwTtl decNwTtl = (OFActionDecNwTtl) act;
builder.decNwTtl();
break;
case SET_TP_DST:
case SET_TP_SRC:
case POP_PBB:
case POP_VLAN:
case PUSH_PBB:
case PUSH_VLAN:
case SET_MPLS_LABEL:
case SET_MPLS_TC:
case SET_MPLS_TTL:
case SET_NW_ECN:
case SET_NW_TOS:
case SET_NW_TTL:
case SET_QUEUE:
case STRIP_VLAN:
case ENQUEUE:
case GROUP:
default:
log.warn("Action type {} not yet implemented.", act.getType());
}
}
return builder.build();
}
private void handleSetField(TrafficTreatment.Builder builder, OFOxm<?> oxm) {
switch (oxm.getMatchField().id) {
case VLAN_PCP:
@SuppressWarnings("unchecked")
OFOxm<VlanPcp> vlanpcp = (OFOxm<VlanPcp>) oxm;
builder.setVlanPcp(vlanpcp.getValue().getValue());
break;
case VLAN_VID:
@SuppressWarnings("unchecked")
OFOxm<OFVlanVidMatch> vlanvid = (OFOxm<OFVlanVidMatch>) oxm;
builder.setVlanId(VlanId.vlanId(vlanvid.getValue().getVlan()));
break;
case ETH_DST:
@SuppressWarnings("unchecked")
OFOxm<org.projectfloodlight.openflow.types.MacAddress> ethdst =
(OFOxm<org.projectfloodlight.openflow.types.MacAddress>) oxm;
builder.setEthDst(MacAddress.valueOf(ethdst.getValue().getLong()));
break;
case ETH_SRC:
@SuppressWarnings("unchecked")
OFOxm<org.projectfloodlight.openflow.types.MacAddress> ethsrc =
(OFOxm<org.projectfloodlight.openflow.types.MacAddress>) oxm;
builder.setEthSrc(MacAddress.valueOf(ethsrc.getValue().getLong()));
break;
case IPV4_DST:
@SuppressWarnings("unchecked")
OFOxm<IPv4Address> ip4dst = (OFOxm<IPv4Address>) oxm;
builder.setIpDst(Ip4Address.valueOf(ip4dst.getValue().getInt()));
break;
case IPV4_SRC:
@SuppressWarnings("unchecked")
OFOxm<IPv4Address> ip4src = (OFOxm<IPv4Address>) oxm;
builder.setIpSrc(Ip4Address.valueOf(ip4src.getValue().getInt()));
break;
case MPLS_LABEL:
@SuppressWarnings("unchecked")
OFOxm<U32> labelId = (OFOxm<U32>) oxm;
builder.setMpls((int) labelId.getValue().getValue());
break;
case ARP_OP:
case ARP_SHA:
case ARP_SPA:
case ARP_THA:
case ARP_TPA:
case BSN_EGR_PORT_GROUP_ID:
case BSN_GLOBAL_VRF_ALLOWED:
case BSN_IN_PORTS_128:
case BSN_L3_DST_CLASS_ID:
case BSN_L3_INTERFACE_CLASS_ID:
case BSN_L3_SRC_CLASS_ID:
case BSN_LAG_ID:
case BSN_TCP_FLAGS:
case BSN_UDF0:
case BSN_UDF1:
case BSN_UDF2:
case BSN_UDF3:
case BSN_UDF4:
case BSN_UDF5:
case BSN_UDF6:
case BSN_UDF7:
case BSN_VLAN_XLATE_PORT_GROUP_ID:
case BSN_VRF:
case ETH_TYPE:
case ICMPV4_CODE:
case ICMPV4_TYPE:
case ICMPV6_CODE:
case ICMPV6_TYPE:
case IN_PHY_PORT:
case IN_PORT:
case IPV6_DST:
case IPV6_FLABEL:
case IPV6_ND_SLL:
case IPV6_ND_TARGET:
case IPV6_ND_TLL:
case IPV6_SRC:
case IP_DSCP:
case IP_ECN:
case IP_PROTO:
case METADATA:
case MPLS_TC:
case OCH_SIGID:
case OCH_SIGID_BASIC:
case OCH_SIGTYPE:
case OCH_SIGTYPE_BASIC:
case SCTP_DST:
case SCTP_SRC:
case TCP_DST:
case TCP_SRC:
case TUNNEL_ID:
case UDP_DST:
case UDP_SRC:
default:
log.warn("Set field type {} not yet implemented.", oxm.getMatchField().id);
break;
}
}
}
/*
* Copyright 2015 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.provider.of.group.impl;
import org.onlab.packet.Ip4Address;
import org.onosproject.core.GroupId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.flow.TrafficTreatment;
import org.onosproject.net.flow.instructions.Instruction;
import org.onosproject.net.flow.instructions.Instructions;
import org.onosproject.net.flow.instructions.L0ModificationInstruction;
import org.onosproject.net.flow.instructions.L2ModificationInstruction;
import org.onosproject.net.flow.instructions.L3ModificationInstruction;
import org.onosproject.net.group.GroupBucket;
import org.onosproject.net.group.GroupBuckets;
import org.onosproject.net.group.GroupDescription;
import org.projectfloodlight.openflow.protocol.OFBucket;
import org.projectfloodlight.openflow.protocol.OFFactory;
import org.projectfloodlight.openflow.protocol.OFGroupAdd;
import org.projectfloodlight.openflow.protocol.OFGroupDelete;
import org.projectfloodlight.openflow.protocol.OFGroupMod;
import org.projectfloodlight.openflow.protocol.OFGroupType;
import org.projectfloodlight.openflow.protocol.action.OFAction;
import org.projectfloodlight.openflow.protocol.action.OFActionOutput;
import org.projectfloodlight.openflow.protocol.oxm.OFOxm;
import org.projectfloodlight.openflow.types.CircuitSignalID;
import org.projectfloodlight.openflow.types.EthType;
import org.projectfloodlight.openflow.types.IPv4Address;
import org.projectfloodlight.openflow.types.MacAddress;
import org.projectfloodlight.openflow.types.OFGroup;
import org.projectfloodlight.openflow.types.OFPort;
import org.projectfloodlight.openflow.types.OFVlanVidMatch;
import org.projectfloodlight.openflow.types.U32;
import org.projectfloodlight.openflow.types.VlanPcp;
import org.slf4j.Logger;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import static org.slf4j.LoggerFactory.getLogger;
/*
* Builder for GroupMod.
*/
public final class GroupModBuilder {
private GroupBuckets buckets;
private GroupId groupId;
private GroupDescription.Type type;
private OFFactory factory;
private Long xid;
private final Logger log = getLogger(getClass());
private static final int OFPCML_NO_BUFFER = 0xffff;
private GroupModBuilder(GroupBuckets buckets, GroupId groupId,
GroupDescription.Type type, OFFactory factory,
Optional<Long> xid) {
this.buckets = buckets;
this.groupId = groupId;
this.type = type;
this.factory = factory;
this.xid = xid.orElse((long) 0);
}
/**
* Creates a builder for GroupMod.
*
* @param buckets GroupBuckets object
* @param groupId Group Id to create
* @param type Group type
* @param factory OFFactory object
* @param xid transaction ID
* @return GroupModBuilder object
*/
public static GroupModBuilder builder(GroupBuckets buckets, GroupId groupId,
GroupDescription.Type type, OFFactory factory,
Optional<Long> xid) {
return new GroupModBuilder(buckets, groupId, type, factory, xid);
}
/**
* Builds the GroupAdd OF message.
*
* @return GroupAdd OF message
*/
public OFGroupAdd buildGroupAdd() {
List<OFBucket> ofBuckets = new ArrayList<OFBucket>();
for (GroupBucket bucket: buckets.buckets()) {
List<OFAction> actions = buildActions(bucket.treatment());
OFBucket.Builder bucketBuilder = factory.buildBucket();
bucketBuilder.setActions(actions);
if (type == GroupDescription.Type.SELECT) {
bucketBuilder.setWeight(1);
}
bucketBuilder.setWatchGroup(OFGroup.ANY);
bucketBuilder.setWatchPort(OFPort.ANY);
OFBucket ofBucket = bucketBuilder.build();
ofBuckets.add(ofBucket);
}
OFGroupAdd groupMsg = factory.buildGroupAdd()
.setGroup(OFGroup.of(groupId.id()))
.setBuckets(ofBuckets)
.setGroupType(getOFGroupType(type))
.setXid(xid)
.build();
return groupMsg;
}
/**
* Builds the GroupMod OF message.
*
* @return GroupMod OF message
*/
public OFGroupMod buildGroupMod() {
List<OFBucket> ofBuckets = new ArrayList<OFBucket>();
for (GroupBucket bucket: buckets.buckets()) {
List<OFAction> actions = buildActions(bucket.treatment());
OFBucket.Builder bucketBuilder = factory.buildBucket();
bucketBuilder.setActions(actions);
if (type == GroupDescription.Type.SELECT) {
bucketBuilder.setWeight(1);
}
bucketBuilder.setWatchGroup(OFGroup.ANY);
bucketBuilder.setWatchPort(OFPort.ANY);
OFBucket ofBucket = bucketBuilder.build();
ofBuckets.add(ofBucket);
}
OFGroupMod groupMsg = factory.buildGroupModify()
.setGroup(OFGroup.of(groupId.id()))
.setBuckets(ofBuckets)
.setGroupType(getOFGroupType(type))
.setXid(xid)
.build();
return groupMsg;
}
/**
* Builds the GroupDel OF message.
*
* @return GroupDel OF message
*/
public OFGroupDelete buildGroupDel() {
OFGroupDelete groupMsg = factory.buildGroupDelete()
.setGroup(OFGroup.of(groupId.id()))
.setGroupType(OFGroupType.SELECT)
.setXid(xid)
.build();
return groupMsg;
}
private List<OFAction> buildActions(TrafficTreatment treatment) {
List<OFAction> actions = new LinkedList<>();
if (treatment == null) {
return actions;
}
for (Instruction i : treatment.instructions()) {
switch (i.type()) {
case DROP:
log.warn("Saw drop action; assigning drop action");
return new LinkedList<>();
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:
default:
log.warn("Instruction type {} not yet implemented.", i.type());
}
}
return actions;
}
private OFAction buildL0Modification(Instruction i) {
L0ModificationInstruction l0m = (L0ModificationInstruction) i;
switch (l0m.subtype()) {
case LAMBDA:
L0ModificationInstruction.ModLambdaInstruction ml =
(L0ModificationInstruction.ModLambdaInstruction) i;
return factory.actions().circuit(factory.oxms().ochSigidBasic(
new CircuitSignalID((byte) 1, (byte) 2, ml.lambda(), (short) 1)));
default:
log.warn("Unimplemented action type {}.", l0m.subtype());
break;
}
return null;
}
private OFAction buildL2Modification(Instruction i) {
L2ModificationInstruction l2m = (L2ModificationInstruction) i;
L2ModificationInstruction.ModEtherInstruction eth;
OFOxm<?> oxm = null;
switch (l2m.subtype()) {
case ETH_DST:
eth = (L2ModificationInstruction.ModEtherInstruction) l2m;
oxm = factory.oxms().ethDst(MacAddress.of(eth.mac().toLong()));
break;
case ETH_SRC:
eth = (L2ModificationInstruction.ModEtherInstruction) l2m;
oxm = factory.oxms().ethSrc(MacAddress.of(eth.mac().toLong()));
break;
case VLAN_ID:
L2ModificationInstruction.ModVlanIdInstruction vlanId =
(L2ModificationInstruction.ModVlanIdInstruction) l2m;
oxm = factory.oxms().vlanVid(OFVlanVidMatch.ofVlan(vlanId.vlanId().toShort()));
break;
case VLAN_PCP:
L2ModificationInstruction.ModVlanPcpInstruction vlanPcp =
(L2ModificationInstruction.ModVlanPcpInstruction) l2m;
oxm = factory.oxms().vlanPcp(VlanPcp.of(vlanPcp.vlanPcp()));
break;
case MPLS_PUSH:
L2ModificationInstruction.PushHeaderInstructions pushHeaderInstructions =
(L2ModificationInstruction.PushHeaderInstructions) l2m;
return factory.actions().pushMpls(EthType.of(pushHeaderInstructions
.ethernetType().getEtherType()));
case MPLS_POP:
L2ModificationInstruction.PushHeaderInstructions popHeaderInstructions =
(L2ModificationInstruction.PushHeaderInstructions) l2m;
return factory.actions().popMpls(EthType.of(popHeaderInstructions
.ethernetType().getEtherType()));
case MPLS_LABEL:
L2ModificationInstruction.ModMplsLabelInstruction mplsLabel =
(L2ModificationInstruction.ModMplsLabelInstruction) l2m;
oxm = factory.oxms().mplsLabel(U32.of(mplsLabel.label()
.longValue()));
break;
case DEC_MPLS_TTL:
return factory.actions().decMplsTtl();
default:
log.warn("Unimplemented action type {}.", l2m.subtype());
break;
}
if (oxm != null) {
return factory.actions().buildSetField().setField(oxm).build();
}
return null;
}
private OFAction buildL3Modification(Instruction i) {
L3ModificationInstruction l3m = (L3ModificationInstruction) i;
L3ModificationInstruction.ModIPInstruction ip;
Ip4Address ip4;
OFOxm<?> oxm = null;
switch (l3m.subtype()) {
case IP_DST:
ip = (L3ModificationInstruction.ModIPInstruction) i;
ip4 = ip.ip().getIp4Address();
oxm = factory.oxms().ipv4Dst(IPv4Address.of(ip4.toInt()));
break;
case IP_SRC:
ip = (L3ModificationInstruction.ModIPInstruction) i;
ip4 = ip.ip().getIp4Address();
oxm = factory.oxms().ipv4Src(IPv4Address.of(ip4.toInt()));
break;
case DEC_TTL:
return factory.actions().decNwTtl();
case TTL_IN:
return factory.actions().copyTtlIn();
case TTL_OUT:
return factory.actions().copyTtlOut();
default:
log.warn("Unimplemented action type {}.", l3m.subtype());
break;
}
if (oxm != null) {
return factory.actions().buildSetField().setField(oxm).build();
}
return null;
}
private OFGroupType getOFGroupType(GroupDescription.Type groupType) {
switch (groupType) {
case INDIRECT:
return OFGroupType.INDIRECT;
case SELECT:
return OFGroupType.SELECT;
case FAILOVER:
return OFGroupType.FF;
case ALL:
return OFGroupType.ALL;
default:
log.error("Unsupported group type : {}", groupType);
break;
}
return null;
}
}
/*
* Copyright 2015 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.provider.of.group.impl;
import org.jboss.netty.util.HashedWheelTimer;
import org.jboss.netty.util.Timeout;
import org.jboss.netty.util.TimerTask;
import org.onlab.util.Timer;
import org.onosproject.openflow.controller.OpenFlowSwitch;
import org.onosproject.openflow.controller.RoleState;
import org.projectfloodlight.openflow.protocol.OFGroupDescStatsRequest;
import org.projectfloodlight.openflow.protocol.OFGroupStatsRequest;
import org.projectfloodlight.openflow.types.OFGroup;
import org.slf4j.Logger;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import static org.slf4j.LoggerFactory.getLogger;
/*
* Sends Group Stats Request and collect the group statistics with a time interval.
*/
public class GroupStatsCollector implements TimerTask {
private final HashedWheelTimer timer = Timer.getTimer();
private final OpenFlowSwitch sw;
private final Logger log = getLogger(getClass());
private final int refreshInterval;
private Timeout timeout;
private final AtomicLong xidCounter = new AtomicLong(1);
private boolean stopTimer = false;
/**
* Creates a GroupStatsCollector object.
*
* @param sw Open Flow switch
* @param interval time interval for collecting group statistic
*/
public GroupStatsCollector(OpenFlowSwitch sw, int interval) {
this.sw = sw;
this.refreshInterval = interval;
}
@Override
public void run(Timeout timeout) throws Exception {
log.trace("Collecting stats for {}", sw.getStringId());
sendGroupStatistic();
if (!this.stopTimer) {
log.trace("Scheduling stats collection in {} seconds for {}",
this.refreshInterval, this.sw.getStringId());
timeout.getTimer().newTimeout(this, refreshInterval,
TimeUnit.SECONDS);
}
}
private void sendGroupStatistic() {
if (log.isTraceEnabled()) {
log.trace("sendGroupStatistics {}:{}", sw.getStringId(), sw.getRole());
}
if (sw.getRole() != RoleState.MASTER) {
return;
}
Long statsXid = xidCounter.getAndAdd(2);
OFGroupStatsRequest statsRequest = sw.factory().buildGroupStatsRequest()
.setGroup(OFGroup.ALL)
.setXid(statsXid)
.build();
sw.sendMsg(statsRequest);
Long descXid = statsXid + 1;
OFGroupDescStatsRequest descStatsRequest =
sw.factory().buildGroupDescStatsRequest()
.setXid(descXid)
.build();
sw.sendMsg(descStatsRequest);
}
/**
* Starts the collector.
*/
public void start() {
log.info("Staring Group Stats collection thread for {}", sw.getStringId());
timeout = timer.newTimeout(this, 1, TimeUnit.SECONDS);
}
/**
* Stops the collector.
*/
public void stop() {
log.info("Stopping Group Stats collection thread for {}", sw.getStringId());
this.stopTimer = true;
timeout.cancel();
}
}
/*
* Copyright 2015 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.provider.of.group.impl;
import com.google.common.collect.Maps;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.core.GroupId;
import org.onosproject.net.DeviceId;
import org.onosproject.net.group.DefaultGroup;
import org.onosproject.net.group.Group;
import org.onosproject.net.group.GroupBuckets;
import org.onosproject.net.group.GroupDescription;
import org.onosproject.net.group.GroupOperation;
import org.onosproject.net.group.GroupOperations;
import org.onosproject.net.group.GroupProvider;
import org.onosproject.net.group.GroupProviderRegistry;
import org.onosproject.net.group.GroupProviderService;
import org.onosproject.net.provider.AbstractProvider;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.openflow.controller.Dpid;
import org.onosproject.openflow.controller.OpenFlowController;
import org.onosproject.openflow.controller.OpenFlowEventListener;
import org.onosproject.openflow.controller.OpenFlowSwitch;
import org.onosproject.openflow.controller.OpenFlowSwitchListener;
import org.onosproject.openflow.controller.RoleState;
import org.projectfloodlight.openflow.protocol.OFErrorMsg;
import org.projectfloodlight.openflow.protocol.OFErrorType;
import org.projectfloodlight.openflow.protocol.OFGroupDescStatsEntry;
import org.projectfloodlight.openflow.protocol.OFGroupDescStatsReply;
import org.projectfloodlight.openflow.protocol.OFGroupMod;
import org.projectfloodlight.openflow.protocol.OFGroupStatsEntry;
import org.projectfloodlight.openflow.protocol.OFGroupStatsReply;
import org.projectfloodlight.openflow.protocol.OFGroupType;
import org.projectfloodlight.openflow.protocol.OFMessage;
import org.projectfloodlight.openflow.protocol.OFPortStatus;
import org.projectfloodlight.openflow.protocol.OFStatsReply;
import org.projectfloodlight.openflow.protocol.OFStatsType;
import org.slf4j.Logger;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;
import static org.slf4j.LoggerFactory.getLogger;
/**
* Provider which uses an OpenFlow controller to handle Group.
*/
@Component(immediate = true)
public class OpenFlowGroupProvider extends AbstractProvider implements GroupProvider {
private final Logger log = getLogger(getClass());
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected OpenFlowController controller;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected GroupProviderRegistry providerRegistry;
private GroupProviderService providerService;
static final int POLL_INTERVAL = 10;
private final InternalGroupProvider listener = new InternalGroupProvider();
private final AtomicLong xidCounter = new AtomicLong(1);
private final Map<Dpid, GroupStatsCollector> collectors = Maps.newHashMap();
private final Map<Long, OFStatsReply> groupStats = Maps.newHashMap();
private final Map<Long, GroupOperation> pendingGroupOperations =
Maps.newConcurrentMap();
/**
* Creates a OpenFlow group provider.
*/
public OpenFlowGroupProvider() {
super(new ProviderId("of", "org.onosproject.provider.group"));
}
@Activate
public void activate() {
providerService = providerRegistry.register(this);
controller.addListener(listener);
controller.addEventListener(listener);
for (OpenFlowSwitch sw : controller.getSwitches()) {
GroupStatsCollector gsc = new GroupStatsCollector(sw, POLL_INTERVAL);
gsc.start();
collectors.put(new Dpid(sw.getId()), gsc);
}
log.info("Started");
}
@Deactivate
public void deactivate() {
providerRegistry.unregister(this);
providerService = null;
log.info("Stopped");
}
@Override
public void performGroupOperation(DeviceId deviceId, GroupOperations groupOps) {
Map<OFGroupMod, OpenFlowSwitch> mods = Maps.newIdentityHashMap();
final Dpid dpid = Dpid.dpid(deviceId.uri());
OpenFlowSwitch sw = controller.getSwitch(dpid);
for (GroupOperation groupOperation: groupOps.operations()) {
if (sw == null) {
log.error("SW {} is not found", sw.getStringId());
return;
}
final Long groupModXid = xidCounter.getAndIncrement();
GroupModBuilder builder =
GroupModBuilder.builder(groupOperation.buckets(),
groupOperation.groupId(),
groupOperation.groupType(),
sw.factory(),
Optional.of(groupModXid));
OFGroupMod groupMod = null;
switch (groupOperation.opType()) {
case ADD:
groupMod = builder.buildGroupAdd();
break;
case MODIFY:
groupMod = builder.buildGroupMod();
break;
case DELETE:
groupMod = builder.buildGroupDel();
break;
default:
log.error("Unsupported Group operation");
}
sw.sendMsg(groupMod);
pendingGroupOperations.put(groupModXid, groupOperation);
}
}
private void pushGroupMetrics(Dpid dpid, OFStatsReply statsReply) {
DeviceId deviceId = DeviceId.deviceId(Dpid.uri(dpid));
OFGroupStatsReply groupStatsReply = null;
OFGroupDescStatsReply groupDescStatsReply = null;
if (statsReply.getStatsType() == OFStatsType.GROUP) {
OFStatsReply reply = groupStats.get(statsReply.getXid() + 1);
if (reply != null) {
groupStatsReply = (OFGroupStatsReply) statsReply;
groupDescStatsReply = (OFGroupDescStatsReply) reply;
groupStats.remove(statsReply.getXid() + 1);
} else {
groupStats.put(statsReply.getXid(), statsReply);
}
} else if (statsReply.getStatsType() == OFStatsType.GROUP_DESC) {
OFStatsReply reply = groupStats.get(statsReply.getXid() - 1);
if (reply != null) {
groupStatsReply = (OFGroupStatsReply) reply;
groupDescStatsReply = (OFGroupDescStatsReply) statsReply;
groupStats.remove(statsReply.getXid() - 1);
} else {
groupStats.put(statsReply.getXid(), statsReply);
}
}
if (groupStatsReply != null && groupDescStatsReply != null) {
Collection<Group> groups = buildGroupMetrics(deviceId,
groupStatsReply, groupDescStatsReply);
providerService.pushGroupMetrics(deviceId, groups);
for (Group group: groups) {
pendingGroupOperations.remove(group.id());
}
}
}
private Collection<Group> buildGroupMetrics(DeviceId deviceId,
OFGroupStatsReply groupStatsReply,
OFGroupDescStatsReply groupDescStatsReply) {
Map<Integer, Group> groups = Maps.newHashMap();
for (OFGroupDescStatsEntry entry: groupDescStatsReply.getEntries()) {
int id = entry.getGroup().getGroupNumber();
GroupId groupId = new DefaultGroupId(id);
GroupDescription.Type type = getGroupType(entry.getGroupType());
GroupBuckets buckets = new GroupBucketEntryBuilder(entry.getBuckets(),
entry.getGroupType()).build();
DefaultGroup group = new DefaultGroup(groupId, deviceId, type, buckets);
groups.put(id, group);
}
for (OFGroupStatsEntry entry: groupStatsReply.getEntries()) {
int groupId = entry.getGroup().getGroupNumber();
DefaultGroup group = (DefaultGroup) groups.get(groupId);
if (group != null) {
group.setBytes(entry.getByteCount().getValue());
group.setLife(entry.getDurationSec());
group.setPackets(entry.getPacketCount().getValue());
group.setReferenceCount(entry.getRefCount());
}
}
return groups.values();
}
private GroupDescription.Type getGroupType(OFGroupType type) {
switch (type) {
case ALL:
return GroupDescription.Type.ALL;
case INDIRECT:
return GroupDescription.Type.INDIRECT;
case SELECT:
return GroupDescription.Type.SELECT;
case FF:
return GroupDescription.Type.FAILOVER;
default:
log.error("Unsupported OF group type : {}", type);
break;
}
return null;
}
private class InternalGroupProvider
implements OpenFlowSwitchListener, OpenFlowEventListener {
@Override
public void handleMessage(Dpid dpid, OFMessage msg) {
switch (msg.getType()) {
case STATS_REPLY:
pushGroupMetrics(dpid, (OFStatsReply) msg);
break;
case ERROR:
OFErrorMsg errorMsg = (OFErrorMsg) msg;
if (errorMsg.getErrType() == OFErrorType.GROUP_MOD_FAILED) {
GroupOperation operation =
pendingGroupOperations.get(errorMsg.getXid());
if (operation != null) {
providerService.groupOperationFailed(operation);
log.warn("received Error message {} from {}", msg, dpid);
}
break;
}
default:
log.debug("Unhandled message type: {}", msg.getType());
}
}
@Override
public void switchAdded(Dpid dpid) {
GroupStatsCollector gsc = new GroupStatsCollector(
controller.getSwitch(dpid), POLL_INTERVAL);
gsc.start();
collectors.put(dpid, gsc);
}
@Override
public void switchRemoved(Dpid dpid) {
GroupStatsCollector collector = collectors.remove(dpid);
if (collector != null) {
collector.stop();
}
}
@Override
public void switchChanged(Dpid dpid) {
}
@Override
public void portChanged(Dpid dpid, OFPortStatus status) {
}
@Override
public void receivedRoleReply(Dpid dpid, RoleState requested, RoleState response) {
}
}
}
......@@ -37,6 +37,7 @@
<module>host</module>
<module>packet</module>
<module>flow</module>
<module>group</module>
</modules>
<dependencies>
......