import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.flow.update.OriginalFlowBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.flow.update.UpdatedFlowBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.OriginalGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.UpdatedGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.config.rev131024.Meters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.config.rev131024.meters.Meter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.config.rev131024.meters.MeterKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.SalMeterListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.SalMeterService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.UpdateMeterInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.meter.update.OriginalMeterBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.meter.update.UpdatedMeterBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.BandType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.Drop;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.DscpRemark;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class MeterConsumerImpl implements IForwardingRulesManager {
+public class MeterConsumerImpl {
protected static final Logger logger = LoggerFactory.getLogger(MeterConsumerImpl.class);
private final MeterEventListener meterEventListener = new MeterEventListener();
private Registration<NotificationListener> meterListener;
private SalMeterService meterService;
private MeterDataCommitHandler commitHandler;
- private ConcurrentMap<MeterKey, Meter> originalSwMeterView;
- @SuppressWarnings("unused")
- private ConcurrentMap<MeterKey, Meter> installedSwMeterView;
- @SuppressWarnings("unused")
- private ConcurrentMap<Node, List<Meter>> nodeMeters;
- @SuppressWarnings("unused")
- private ConcurrentMap<MeterKey, Meter> inactiveMeters;
- @SuppressWarnings("unused")
- private IContainer container;
-
- private IClusterContainerServices clusterMeterContainerService = null;
-
-
public MeterConsumerImpl() {
- InstanceIdentifier<? extends DataObject> path = InstanceIdentifier.builder(Meters.class).child(Meter.class)
- .toInstance();
+ InstanceIdentifier<? extends DataObject> path = InstanceIdentifier.builder(Meters.class).toInstance();
meterService = FRMConsumerImpl.getProviderSession().getRpcService(SalMeterService.class);
- clusterMeterContainerService = FRMConsumerImpl.getClusterContainerService();
-
- container = FRMConsumerImpl.getContainer();
-
- if (!(cacheStartup())) {
- logger.error("Unable to allocate/retrieve meter cache");
- System.out.println("Unable to allocate/retrieve meter cache");
- }
-
+
if (null == meterService) {
logger.error("Consumer SAL Meter Service is down or NULL. FRM may not function as intended");
System.out.println("Consumer SAL Meter Service is down or NULL.");
commitHandler = new MeterDataCommitHandler();
FRMConsumerImpl.getDataProviderService().registerCommitHandler(path, commitHandler);
}
-
- private boolean allocateMeterCaches() {
- if (this.clusterMeterContainerService == null) {
- logger.warn("Meter: Un-initialized clusterMeterContainerService, can't create cache");
- return false;
- }
-
- try {
- clusterMeterContainerService.createCache("frm.originalSwMeterView",
- EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
-
- clusterMeterContainerService.createCache("frm.installedSwMeterView",
- EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
-
- clusterMeterContainerService.createCache("frm.inactiveMeters",
- EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
-
- clusterMeterContainerService.createCache("frm.nodeMeters",
- EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
-
- // TODO for cluster mode
- /*
- * clusterMeterContainerService.createCache(WORK_STATUS_CACHE,
- * EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL,
- * IClusterServices.cacheMode.ASYNC));
- *
- * clusterMeterContainerService.createCache(WORK_ORDER_CACHE,
- * EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL,
- * IClusterServices.cacheMode.ASYNC));
- */
-
- } catch (CacheConfigException cce) {
- logger.error("Meter CacheConfigException");
- return false;
-
- } catch (CacheExistException cce) {
- logger.error(" Meter CacheExistException");
- }
-
- return true;
- }
-
- private void nonClusterMeterObjectCreate() {
- originalSwMeterView = new ConcurrentHashMap<MeterKey, Meter>();
- installedSwMeterView = new ConcurrentHashMap<MeterKey, Meter>();
- nodeMeters = new ConcurrentHashMap<Node, List<Meter>>();
- inactiveMeters = new ConcurrentHashMap<MeterKey, Meter>();
- }
-
- @SuppressWarnings({ "unchecked" })
- private boolean retrieveMeterCaches() {
- ConcurrentMap<?, ?> map;
-
- if (this.clusterMeterContainerService == null) {
- logger.warn("Meter: un-initialized clusterMeterContainerService, can't retrieve cache");
- nonClusterMeterObjectCreate();
- return false;
- }
-
- map = clusterMeterContainerService.getCache("frm.originalSwMeterView");
- if (map != null) {
- originalSwMeterView = (ConcurrentMap<MeterKey, Meter>) map;
- } else {
- logger.error("Retrieval of cache(originalSwMeterView) failed");
- return false;
- }
-
- map = clusterMeterContainerService.getCache("frm.installedSwMeterView");
- if (map != null) {
- installedSwMeterView = (ConcurrentMap<MeterKey, Meter>) map;
- } else {
- logger.error("Retrieval of cache(installedSwMeterView) failed");
- return false;
- }
-
- map = clusterMeterContainerService.getCache("frm.inactiveMeters");
- if (map != null) {
- inactiveMeters = (ConcurrentMap<MeterKey, Meter>) map;
- } else {
- logger.error("Retrieval of cache(inactiveMeters) failed");
- return false;
- }
-
- map = clusterMeterContainerService.getCache("frm.nodeMeters");
- if (map != null) {
- nodeMeters = (ConcurrentMap<Node, List<Meter>>) map;
- } else {
- logger.error("Retrieval of cache(nodeMeter) failed");
- return false;
- }
-
- return true;
- }
-
- private boolean cacheStartup() {
- if (allocateMeterCaches()) {
- if (retrieveMeterCaches()) {
- return true;
- }
- }
-
- return false;
- }
-
+
/**
* Adds Meter to the southbound plugin and our internal database
*
*/
private Status addMeter(InstanceIdentifier<?> path, Meter meterAddDataObject) {
MeterKey meterKey = meterAddDataObject.getKey();
-
- if (null != meterKey && validateMeter(meterAddDataObject, FRMUtil.operation.ADD).isSuccess()) {
- if (meterAddDataObject.isInstall()) {
- AddMeterInputBuilder meterBuilder = new AddMeterInputBuilder();
-
- meterBuilder.setContainerName(meterAddDataObject.getContainerName());
- meterBuilder.setFlags(meterAddDataObject.getFlags());
- meterBuilder.setMeterBandHeaders(meterAddDataObject.getMeterBandHeaders());
- meterBuilder.setMeterId(meterAddDataObject.getMeterId());
- meterBuilder.setNode(meterAddDataObject.getNode());
- // originalSwMeterView.put(meterKey, meterAddDataObject);
- meterService.addMeter(meterBuilder.build());
- }
-
- // originalSwMeterView.put(meterKey, meterAddDataObject);
- } else {
+
+ if (null != meterKey && validateMeter(meterAddDataObject).isSuccess()) {
+ AddMeterInputBuilder meterBuilder = new AddMeterInputBuilder();
+ meterBuilder.fieldsFrom(meterAddDataObject);
+ meterBuilder.setMeterId(new MeterId(meterAddDataObject.getId()));
+ meterBuilder.setNode(meterAddDataObject.getNode());
+ meterService.addMeter(meterBuilder.build());
+ } else {
return new Status(StatusCode.BADREQUEST, "Meter Key or attribute validation failed");
}
*
* @param dataObject
*/
- private Status updateMeter(InstanceIdentifier<?> path, Meter meterUpdateDataObject) {
- MeterKey meterKey = meterUpdateDataObject.getKey();
+ private Status updateMeter(InstanceIdentifier<?> path,
+ Meter updatedMeter, Meter originalMeter) {
UpdatedMeterBuilder updateMeterBuilder = null;
-
- if (null != meterKey && validateMeter(meterUpdateDataObject, FRMUtil.operation.UPDATE).isSuccess()) {
-
- /* if (originalSwMeterView.containsKey(meterKey)) {
- originalSwMeterView.remove(meterKey);
- originalSwMeterView.put(meterKey, meterUpdateDataObject);
- }*/
-
- if (meterUpdateDataObject.isInstall()) {
- UpdateMeterInputBuilder updateMeterInputBuilder = new UpdateMeterInputBuilder();
- updateMeterBuilder = new UpdatedMeterBuilder();
- updateMeterBuilder.fieldsFrom(meterUpdateDataObject);
- updateMeterInputBuilder.setUpdatedMeter(updateMeterBuilder.build());
-
- /* if (installedSwMeterView.containsKey(meterKey)) {
- installedSwMeterView.remove(meterKey);
- installedSwMeterView.put(meterKey, meterUpdateDataObject);
- }*/
-
- meterService.updateMeter(updateMeterInputBuilder.build());
- }
-
+
+ if (validateMeter(updatedMeter).isSuccess()) {
+ UpdateMeterInputBuilder updateMeterInputBuilder = new UpdateMeterInputBuilder();
+ updateMeterInputBuilder.setNode(updatedMeter.getNode());
+ updateMeterBuilder = new UpdatedMeterBuilder();
+ updateMeterBuilder.fieldsFrom(updatedMeter);
+ updateMeterBuilder.setMeterId(new MeterId(updatedMeter.getId()));
+ updateMeterInputBuilder.setUpdatedMeter(updateMeterBuilder.build());
+ OriginalMeterBuilder originalMeterBuilder = new OriginalMeterBuilder(originalMeter);
+ updateMeterInputBuilder.setOriginalMeter(originalMeterBuilder.build());
+ meterService.updateMeter(updateMeterInputBuilder.build());
} else {
return new Status(StatusCode.BADREQUEST, "Meter Key or attribute validation failed");
}
private Status removeMeter(InstanceIdentifier<?> path, Meter meterRemoveDataObject) {
MeterKey meterKey = meterRemoveDataObject.getKey();
- if (null != meterKey && validateMeter(meterRemoveDataObject, FRMUtil.operation.DELETE).isSuccess()) {
- if (meterRemoveDataObject.isInstall()) {
- RemoveMeterInputBuilder meterBuilder = new RemoveMeterInputBuilder();
- meterBuilder.setContainerName(meterRemoveDataObject.getContainerName());
- meterBuilder.setNode(meterRemoveDataObject.getNode());
- meterBuilder.setFlags(meterRemoveDataObject.getFlags());
- meterBuilder.setMeterBandHeaders(meterRemoveDataObject.getMeterBandHeaders());
- meterBuilder.setMeterId(meterRemoveDataObject.getMeterId());
- meterBuilder.setNode(meterRemoveDataObject.getNode());
- // originalSwMeterView.put(meterKey, meterAddDataObject);
- meterService.removeMeter(meterBuilder.build());
- }
-
- // originalSwMeterView.put(meterKey, meterAddDataObject);
+ if (null != meterKey && validateMeter(meterRemoveDataObject).isSuccess()) {
+ RemoveMeterInputBuilder meterBuilder = new RemoveMeterInputBuilder();
+ meterBuilder.fieldsFrom(meterRemoveDataObject);
+ meterBuilder.setNode(meterRemoveDataObject.getNode());
+ meterBuilder.setMeterId(new MeterId(meterRemoveDataObject.getId()));
+ meterService.removeMeter(meterBuilder.build());
} else {
return new Status(StatusCode.BADREQUEST, "Meter Key or attribute validation failed");
}
return new Status(StatusCode.SUCCESS);
}
- public Status validateMeter(Meter meter, FRMUtil.operation operation) {
- String containerName;
+ public Status validateMeter(Meter meter) {
String meterName;
Status returnStatus = null;
if (null != meter) {
- containerName = meter.getContainerName();
-
- if (null == containerName) {
- containerName = GlobalConstants.DEFAULT.toString();
- } else if (!FRMUtil.isNameValid(containerName)) {
- logger.error("Container Name is invalid %s" + containerName);
- returnStatus = new Status(StatusCode.BADREQUEST, "Container Name is invalid");
- return returnStatus;
- }
-
meterName = meter.getMeterName();
if (!FRMUtil.isNameValid(meterName)) {
logger.error("Meter Name is invalid %s" + meterName);
return returnStatus;
}
- /* returnResult = doesMeterEntryExists(meter.getKey(), meterName, containerName);
-
- if (FRMUtil.operation.ADD == operation && returnResult) {
- logger.error("Record with same Meter Name exists");
- returnStatus = new Status(StatusCode.BADREQUEST, "Meter record exists");
- return returnStatus;
- } else if (!returnResult) {
- logger.error("Group record does not exist");
- returnStatus = new Status(StatusCode.BADREQUEST, "Meter record does not exist");
- return returnStatus;
- }*/
-
for (int i = 0; i < meter.getMeterBandHeaders().getMeterBandHeader().size(); i++) {
- if (!meter.getFlags().isMeterBurst()) {
+ if (null != meter.getFlags() && !meter.getFlags().isMeterBurst()) {
if (0 < meter.getMeterBandHeaders().getMeterBandHeader().get(i).getBurstSize()) {
logger.error("Burst size should only be associated when Burst FLAG is set");
returnStatus = new Status(StatusCode.BADREQUEST,
if (null != returnStatus && !returnStatus.isSuccess()) {
return returnStatus;
- } else {
+ } else if (null != meter.getMeterBandHeaders()) {
BandType setBandType = null;
DscpRemark dscpRemark = null;
for (int i = 0; i < meter.getMeterBandHeaders().getMeterBandHeader().size(); i++) {
return new Status(StatusCode.SUCCESS);
}
- /*private boolean doesMeterEntryExists(MeterKey key, String meterName, String containerName) {
- if (!originalSwMeterView.containsKey(key)) {
- return false;
- }
-
- for (Entry<MeterKey, Meter> entry : originalSwMeterView.entrySet()) {
- if (entry.getValue().getMeterName().equals(meterName)) {
- if (entry.getValue().getContainerName().equals(containerName)) {
- return true;
- }
- }
+ private RpcResult<Void> commitToPlugin(InternalTransaction transaction) {
+ DataModification<InstanceIdentifier<?>, DataObject> modification = transaction.modification;
+ //get created entries
+ Set<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> createdEntries =
+ modification.getCreatedConfigurationData().entrySet();
+
+ //get updated entries
+ Set<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> updatedEntries =
+ new HashSet<Entry<InstanceIdentifier<? extends DataObject>, DataObject>>();
+
+ updatedEntries.addAll(modification.getUpdatedConfigurationData().entrySet());
+ updatedEntries.removeAll(createdEntries);
+
+ //get removed entries
+ Set<InstanceIdentifier<? extends DataObject>> removeEntriesInstanceIdentifiers =
+ modification.getRemovedConfigurationData();
+
+ for (Entry<InstanceIdentifier<? extends DataObject >, DataObject> entry : createdEntries) {
+ if(entry.getValue() instanceof Meter) {
+ addMeter(entry.getKey(), (Meter)entry.getValue());
+ }
+ }
+
+ for (Entry<InstanceIdentifier<?>, DataObject> entry : updatedEntries) {
+ if(entry.getValue() instanceof Meter) {
+ Meter originalMeter = (Meter) modification.getOriginalConfigurationData().get(entry.getKey());
+ Meter updatedMeter = (Meter) entry.getValue();
+ updateMeter(entry.getKey(), originalMeter, updatedMeter);
+ }
+ }
+
+ for (InstanceIdentifier<?> instanceId : removeEntriesInstanceIdentifiers ) {
+ DataObject removeValue = modification.getOriginalConfigurationData().get(instanceId);
+ if(removeValue instanceof Meter) {
+ removeMeter(instanceId, (Meter)removeValue);
+ }
}
- return false;
- }*/
- private final class InternalTransaction implements DataCommitTransaction<InstanceIdentifier<?>, DataObject> {
+ return Rpcs.getRpcResult(true, null, Collections.<RpcError>emptySet());
+ }
+
+ final class InternalTransaction implements DataCommitTransaction<InstanceIdentifier<?>, DataObject> {
private final DataModification<InstanceIdentifier<?>, DataObject> modification;
this.modification = modification;
}
- Map<InstanceIdentifier<?>, Meter> additions = new HashMap<>();
- Map<InstanceIdentifier<?>, Meter> updates = new HashMap<>();
- Set<InstanceIdentifier<?>> removals = new HashSet<>();
-
/**
* We create a plan which flows will be added, which will be updated and
* which will be removed based on our internal state.
*
*/
- void prepareUpdate() {
+ void prepareUpdate() {
- Set<Entry<InstanceIdentifier<?>, DataObject>> addMeter = modification.getCreatedConfigurationData().entrySet();
- for (Entry<InstanceIdentifier<?>, DataObject> entry : addMeter) {
- if (entry.getValue() instanceof Meter) {
- Meter meter = (Meter) entry.getValue();
- additions.put(entry.getKey(), meter);
- }
-
- }
-
- Set<Entry<InstanceIdentifier<?>, DataObject>> updateMeter = modification.getUpdatedConfigurationData().entrySet();
- for (Entry<InstanceIdentifier<?>, DataObject> entry : updateMeter) {
- if (entry.getValue() instanceof Meter) {
- Meter meter = (Meter) entry.getValue();
- ///will be fixed once getUpdatedConfigurationData returns only updated data not created data with it.
- if (!additions.containsKey(entry.getKey())) {
- updates.put(entry.getKey(), meter);
- }
- }
- }
-
- removals = modification.getRemovedConfigurationData();
}
/**
@Override
public RpcResult<Void> finish() throws IllegalStateException {
- RpcResult<Void> rpcStatus = commitToPlugin(this);
- // We return true if internal transaction is successful.
- // return Rpcs.getRpcResult(true, null, Collections.emptySet());
+ RpcResult<Void> rpcStatus = commitToPlugin(this);
return rpcStatus;
}
*
*/
@Override
- public RpcResult<Void> rollback() throws IllegalStateException {
- // NOOP - we did not modified any internal state during
- // requestCommit phase
- // return Rpcs.getRpcResult(true, null, Collections.emptySet());
+ public RpcResult<Void> rollback() throws IllegalStateException {
return Rpcs.getRpcResult(true, null, Collections.<RpcError>emptySet());
}
}
- private RpcResult<Void> commitToPlugin(InternalTransaction transaction) {
- for (Entry<InstanceIdentifier<?>, Meter> entry : transaction.additions.entrySet()) {
-
- if (!addMeter(entry.getKey(), entry.getValue()).isSuccess()) {
- return Rpcs.getRpcResult(false, null, Collections.<RpcError>emptySet());
- }
- }
- for (Entry<InstanceIdentifier<?>, Meter> entry : transaction.updates.entrySet()) {
-
- if (!updateMeter(entry.getKey(), entry.getValue()).isSuccess()) {
- return Rpcs.getRpcResult(false, null, Collections.<RpcError>emptySet());
- }
- }
-
- for (InstanceIdentifier<?> meterId : transaction.removals) {
- DataObject removeValue = transaction.getModification().getOriginalConfigurationData().get(meterId);
-
- if(removeValue instanceof Meter) {
- if(!removeMeter(meterId, (Meter)removeValue).isSuccess()) {
- return Rpcs.getRpcResult(false, null, Collections.<RpcError>emptySet());
- }
- }
- }
-
- return Rpcs.getRpcResult(true, null, Collections.<RpcError>emptySet());
- }
-
private final class MeterDataCommitHandler implements DataCommitHandler<InstanceIdentifier<?>, DataObject> {
@Override
public org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction<InstanceIdentifier<?>, DataObject> requestCommit(
DataModification<InstanceIdentifier<?>, DataObject> modification) {
// We should verify transaction
- System.out.println("Coming in MeterDataCommitHandler");
InternalTransaction transaction = new InternalTransaction(modification);
transaction.prepareUpdate();
return transaction;
// TODO Auto-generated method stub
}
- }
-
- @Override
- public List<DataObject> get() {
-
- List<DataObject> orderedList = new ArrayList<DataObject>();
- Collection<Meter> meterList = originalSwMeterView.values();
- for (Iterator<Meter> iterator = meterList.iterator(); iterator.hasNext();) {
- orderedList.add(iterator.next());
- }
- return orderedList;
- }
-
- @Override
- public DataObject getWithName(String name, Node n) {
- if (this instanceof MeterConsumerImpl) {
- Collection<Meter> meterList = originalSwMeterView.values();
- for (Iterator<Meter> iterator = meterList.iterator(); iterator.hasNext();) {
- Meter meter = iterator.next();
- if (meter.getNode().equals(n) && meter.getMeterName().equals(name)) {
-
- return meter;
- }
- }
- }
- return null;
- }
+ }
}