opendaylight/forwardingrulesmanager_mdsal/openflow/src/main/java/org/opendaylight/controller/forwardingrulesmanager_mdsal/consumer/impl/MeterConsumerImpl.java

   1 package org.opendaylight.controller.forwardingrulesmanager_mdsal.consumer.impl;
   2
   3 import java.util.ArrayList;
   4 import java.util.EnumSet;
   5 import java.util.HashMap;
   6 import java.util.HashSet;
   7 import java.util.List;
   8 import java.util.Map;
   9 import java.util.Set;
  10 import java.util.Map.Entry;
  11 import java.util.concurrent.ConcurrentHashMap;
  12 import java.util.concurrent.ConcurrentMap;
  13
  14 import org.opendaylight.controller.clustering.services.CacheConfigException;
  15 import org.opendaylight.controller.clustering.services.CacheExistException;
  16 import org.opendaylight.controller.clustering.services.IClusterContainerServices;
  17 import org.opendaylight.controller.clustering.services.IClusterServices;
  18 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
  19 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
  20 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction;
  21 import org.opendaylight.controller.sal.common.util.Rpcs;
  22 import org.opendaylight.controller.sal.core.IContainer;
  23 import org.opendaylight.controller.sal.core.Node;
  24 import org.opendaylight.controller.sal.utils.GlobalConstants;
  25 import org.opendaylight.controller.sal.utils.Status;
  26 import org.opendaylight.controller.sal.utils.StatusCode;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.config.rev131024.Meters;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.config.rev131024.meters.MeterKey;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.AddMeterInputBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.MeterAdded;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.MeterRemoved;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.MeterUpdated;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.SalMeterListener;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.SalMeterService;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.UpdateMeterInputBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.BandType;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.Drop;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.DscpRemark;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.Experimenter;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.config.rev131024.meters.Meter;
  41 import org.opendaylight.yangtools.concepts.Registration;
  42 import org.opendaylight.yangtools.yang.binding.DataObject;
  43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  44 import org.opendaylight.yangtools.yang.binding.NotificationListener;
  45 import org.opendaylight.yangtools.yang.common.RpcResult;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48
  49 public class MeterConsumerImpl {
  50     protected static final Logger logger = LoggerFactory.getLogger(MeterConsumerImpl.class);
  51     private MeterEventListener meterEventListener = new MeterEventListener();
  52     private Registration<NotificationListener> meterListener;
  53     private SalMeterService meterService;
  54     private MeterDataCommitHandler commitHandler;
  55
  56     private ConcurrentMap<MeterKey, Meter> originalSwMeterView;
  57     private ConcurrentMap<MeterKey, Meter> installedSwMeterView;
  58
  59     private ConcurrentMap<Node, List<Meter>> nodeMeters;
  60     private ConcurrentMap<MeterKey, Meter> inactiveMeters;
  61
  62     private IClusterContainerServices clusterMeterContainerService = null;
  63     private IContainer container;
  64
  65     public MeterConsumerImpl() {
  66         InstanceIdentifier<? extends DataObject> path = InstanceIdentifier.builder().node(Meters.class)
  67                 .node(Meter.class).toInstance();
  68         meterService = FRMConsumerImpl.getProviderSession().getRpcService(SalMeterService.class);
  69         clusterMeterContainerService = FRMConsumerImpl.getClusterContainerService();
  70
  71         container = FRMConsumerImpl.getContainer();
  72
  73         if (!(cacheStartup())) {
  74             logger.error("Unable to allocate/retrieve meter cache");
  75             System.out.println("Unable to allocate/retrieve meter cache");
  76         }
  77
  78         if (null == meterService) {
  79             logger.error("Consumer SAL Meter Service is down or NULL. FRM may not function as intended");
  80             System.out.println("Consumer SAL Meter Service is down or NULL.");
  81             return;
  82         }
  83
  84         // For switch/plugin events
  85         meterListener = FRMConsumerImpl.getNotificationService().registerNotificationListener(meterEventListener);
  86
  87         if (null == meterListener) {
  88             logger.error("Listener to listen on meter data modifcation events");
  89             System.out.println("Listener to listen on meter data modifcation events.");
  90             return;
  91         }
  92
  93         commitHandler = new MeterDataCommitHandler();
  94         FRMConsumerImpl.getDataProviderService().registerCommitHandler(path, commitHandler);
  95     }
  96
  97     private boolean allocateMeterCaches() {
  98         if (this.clusterMeterContainerService == null) {
  99             logger.warn("Meter: Un-initialized clusterMeterContainerService, can't create cache");
 100             return false;
 101         }
 102
 103         try {
 104             clusterMeterContainerService.createCache("frm.originalSwMeterView",
 105                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 106
 107             clusterMeterContainerService.createCache("frm.installedSwMeterView",
 108                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 109
 110             clusterMeterContainerService.createCache("frm.inactiveMeters",
 111                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 112
 113             clusterMeterContainerService.createCache("frm.nodeMeters",
 114                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 115
 116             // TODO for cluster mode
 117             /*
 118              * clusterMeterContainerService.createCache(WORK_STATUS_CACHE,
 119              * EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL,
 120              * IClusterServices.cacheMode.ASYNC));
 121              *
 122              * clusterMeterContainerService.createCache(WORK_ORDER_CACHE,
 123              * EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL,
 124              * IClusterServices.cacheMode.ASYNC));
 125              */
 126
 127         } catch (CacheConfigException cce) {
 128             logger.error("Meter CacheConfigException");
 129             return false;
 130
 131         } catch (CacheExistException cce) {
 132             logger.error(" Meter CacheExistException");
 133         }
 134
 135         return true;
 136     }
 137
 138     private void nonClusterMeterObjectCreate() {
 139         originalSwMeterView = new ConcurrentHashMap<MeterKey, Meter>();
 140         installedSwMeterView = new ConcurrentHashMap<MeterKey, Meter>();
 141         nodeMeters = new ConcurrentHashMap<Node, List<Meter>>();
 142         inactiveMeters = new ConcurrentHashMap<MeterKey, Meter>();
 143     }
 144
 145     @SuppressWarnings({ "unchecked" })
 146     private boolean retrieveMeterCaches() {
 147         ConcurrentMap<?, ?> map;
 148
 149         if (this.clusterMeterContainerService == null) {
 150             logger.warn("Meter: un-initialized clusterMeterContainerService, can't retrieve cache");
 151             nonClusterMeterObjectCreate();
 152             return false;
 153         }
 154
 155         map = clusterMeterContainerService.getCache("frm.originalSwMeterView");
 156         if (map != null) {
 157             originalSwMeterView = (ConcurrentMap<MeterKey, Meter>) map;
 158         } else {
 159             logger.error("Retrieval of cache(originalSwMeterView) failed");
 160             return false;
 161         }
 162
 163         map = clusterMeterContainerService.getCache("frm.installedSwMeterView");
 164         if (map != null) {
 165             installedSwMeterView = (ConcurrentMap<MeterKey, Meter>) map;
 166         } else {
 167             logger.error("Retrieval of cache(installedSwMeterView) failed");
 168             return false;
 169         }
 170
 171         map = clusterMeterContainerService.getCache("frm.inactiveMeters");
 172         if (map != null) {
 173             inactiveMeters = (ConcurrentMap<MeterKey, Meter>) map;
 174         } else {
 175             logger.error("Retrieval of cache(inactiveMeters) failed");
 176             return false;
 177         }
 178
 179         map = clusterMeterContainerService.getCache("frm.nodeMeters");
 180         if (map != null) {
 181             nodeMeters = (ConcurrentMap<Node, List<Meter>>) map;
 182         } else {
 183             logger.error("Retrieval of cache(nodeMeter) failed");
 184             return false;
 185         }
 186
 187         return true;
 188     }
 189
 190     private boolean cacheStartup() {
 191         if (allocateMeterCaches()) {
 192             if (retrieveMeterCaches()) {
 193                 return true;
 194             }
 195         }
 196
 197         return false;
 198     }
 199
 200     /**
 201      * Adds Meter to the southbound plugin and our internal database
 202      *
 203      * @param path
 204      * @param dataObject
 205      */
 206     private Status addMeter(InstanceIdentifier<?> path, Meter meterAddDataObject) {
 207         MeterKey meterKey = meterAddDataObject.getKey();
 208
 209         if (null != meterKey && validateMeter(meterAddDataObject, FRMUtil.operation.ADD).isSuccess()) {
 210             if (meterAddDataObject.isInstall()) {
 211                 AddMeterInputBuilder meterBuilder = new AddMeterInputBuilder();
 212
 213                 meterBuilder.setContainerName(meterAddDataObject.getContainerName());
 214                 meterBuilder.setFlags(meterAddDataObject.getFlags());
 215                 meterBuilder.setMeterBandHeaders(meterAddDataObject.getMeterBandHeaders());
 216                 meterBuilder.setMeterId(meterAddDataObject.getMeterId());
 217                 meterBuilder.setNode(meterAddDataObject.getNode());
 218                 originalSwMeterView.put(meterKey, meterAddDataObject);
 219                 meterService.addMeter(meterBuilder.build());
 220             }
 221
 222             originalSwMeterView.put(meterKey, meterAddDataObject);
 223         } else {
 224             return new Status(StatusCode.BADREQUEST, "Meter Key or attribute validation failed");
 225         }
 226
 227         return new Status(StatusCode.SUCCESS);
 228     }
 229
 230     /*
 231      * Update Meter to the southbound plugin and our internal database
 232      *
 233      * @param path
 234      *
 235      * @param dataObject
 236      */
 237     private Status updateMeter(InstanceIdentifier<?> path, Meter meterUpdateDataObject) {
 238         MeterKey meterKey = meterUpdateDataObject.getKey();
 239
 240         if (null != meterKey && validateMeter(meterUpdateDataObject, FRMUtil.operation.ADD).isSuccess()) {
 241             if (meterUpdateDataObject.isInstall()) {
 242                 UpdateMeterInputBuilder updateMeterBuilder = new UpdateMeterInputBuilder();
 243
 244                 originalSwMeterView.put(meterKey, meterUpdateDataObject);
 245                 meterService.updateMeter(updateMeterBuilder.build());
 246             }
 247
 248             originalSwMeterView.put(meterKey, meterUpdateDataObject);
 249         } else {
 250             return new Status(StatusCode.BADREQUEST, "Meter Key or attribute validation failed");
 251         }
 252
 253         return new Status(StatusCode.SUCCESS);
 254     }
 255
 256     /*
 257      * Remove Meter to the southbound plugin and our internal database
 258      *
 259      * @param path
 260      *
 261      * @param dataObject
 262      */
 263     private Status RemoveMeter(InstanceIdentifier<?> path, Meter meterUpdateDataObject) {
 264         MeterKey meterKey = meterUpdateDataObject.getKey();
 265
 266         if (null != meterKey && validateMeter(meterUpdateDataObject, FRMUtil.operation.ADD).isSuccess()) {
 267             if (meterUpdateDataObject.isInstall()) {
 268                 UpdateMeterInputBuilder updateMeterBuilder = new UpdateMeterInputBuilder();
 269
 270                 originalSwMeterView.put(meterKey, meterUpdateDataObject);
 271                 meterService.updateMeter(updateMeterBuilder.build());
 272             }
 273
 274             originalSwMeterView.put(meterKey, meterUpdateDataObject);
 275         } else {
 276             return new Status(StatusCode.BADREQUEST, "Meter Key or attribute validation failed");
 277         }
 278
 279         return new Status(StatusCode.SUCCESS);
 280     }
 281
 282     public Status validateMeter(Meter meter, FRMUtil.operation operation) {
 283         String containerName;
 284         String meterName;
 285         Status returnStatus = null;
 286         boolean returnResult;
 287
 288         if (null != meter) {
 289             containerName = meter.getContainerName();
 290
 291             if (null == containerName) {
 292                 containerName = GlobalConstants.DEFAULT.toString();
 293             } else if (!FRMUtil.isNameValid(containerName)) {
 294                 logger.error("Container Name is invalid %s" + containerName);
 295                 returnStatus = new Status(StatusCode.BADREQUEST, "Container Name is invalid");
 296                 return returnStatus;
 297             }
 298
 299             meterName = meter.getMeterName();
 300             if (!FRMUtil.isNameValid(meterName)) {
 301                 logger.error("Meter Name is invalid %s" + meterName);
 302                 returnStatus = new Status(StatusCode.BADREQUEST, "Meter Name is invalid");
 303                 return returnStatus;
 304             }
 305
 306             returnResult = doesMeterEntryExists(meter.getKey(), meterName, containerName);
 307
 308             if (FRMUtil.operation.ADD == operation && returnResult) {
 309                 logger.error("Record with same Meter Name exists");
 310                 returnStatus = new Status(StatusCode.BADREQUEST, "Meter record exists");
 311                 return returnStatus;
 312             } else if (!returnResult) {
 313                 logger.error("Group record does not exist");
 314                 returnStatus = new Status(StatusCode.BADREQUEST, "Meter record does not exist");
 315                 return returnStatus;
 316             }
 317
 318             for (int i = 0; i < meter.getMeterBandHeaders().getMeterBandHeader().size(); i++) {
 319                 if (!meter.getFlags().isMeterBurst()) {
 320                     if (0 < meter.getMeterBandHeaders().getMeterBandHeader().get(i).getBurstSize()) {
 321                         logger.error("Burst size should only be associated when Burst FLAG is set");
 322                         returnStatus = new Status(StatusCode.BADREQUEST,
 323                                 "Burst size should only be associated when Burst FLAG is set");
 324                         break;
 325                     }
 326                 }
 327             }
 328
 329             if (null != returnStatus && !returnStatus.isSuccess()) {
 330                 return returnStatus;
 331             } else {
 332                 BandType setBandType = null;
 333                 DscpRemark dscpRemark = null;
 334                 for (int i = 0; i < meter.getMeterBandHeaders().getMeterBandHeader().size(); i++) {
 335                     setBandType = meter.getMeterBandHeaders().getMeterBandHeader().get(i).getBandType();
 336                     if (setBandType instanceof DscpRemark) {
 337                         dscpRemark = (DscpRemark) setBandType;
 338                         if (0 > dscpRemark.getRate()) {
 339
 340                         }
 341                     } else if (setBandType instanceof Drop) {
 342                         if (0 < dscpRemark.getPercLevel()) {
 343                             logger.error("Number of drop Precedence level");
 344                         }
 345                     } else if (setBandType instanceof Experimenter) {
 346
 347                     }
 348                 }
 349             }
 350         }
 351         return new Status(StatusCode.SUCCESS);
 352     }
 353
 354     private boolean doesMeterEntryExists(MeterKey key, String meterName, String containerName) {
 355         if (!originalSwMeterView.containsKey(key)) {
 356             return false;
 357         }
 358
 359         for (Entry<MeterKey, Meter> entry : originalSwMeterView.entrySet()) {
 360             if (entry.getValue().getMeterName().equals(meterName)) {
 361                 if (entry.getValue().getContainerName().equals(containerName)) {
 362                     return true;
 363                 }
 364             }
 365         }
 366         return false;
 367     }
 368
 369     private RpcResult<Void> commitToPlugin(internalTransaction transaction) {
 370         for (Entry<InstanceIdentifier<?>, Meter> entry : transaction.additions.entrySet()) {
 371
 372             if (!addMeter(entry.getKey(), entry.getValue()).isSuccess()) {
 373                 return Rpcs.getRpcResult(false, null, null);
 374             }
 375         }
 376         for (@SuppressWarnings("unused")
 377         Entry<InstanceIdentifier<?>, Meter> entry : transaction.updates.entrySet()) {
 378
 379             if (!updateMeter(entry.getKey(), entry.getValue()).isSuccess()) {
 380                 return Rpcs.getRpcResult(false, null, null);
 381             }
 382         }
 383
 384         for (InstanceIdentifier<?> removal : transaction.removals) {
 385             /*
 386              * if (!removeMeter(entry.getKey(),entry.getValue()).isSuccess()) {
 387              * return Rpcs.getRpcResult(false, null, null); }
 388              */
 389         }
 390
 391         return Rpcs.getRpcResult(true, null, null);
 392     }
 393
 394     private final class internalTransaction implements DataCommitTransaction<InstanceIdentifier<?>, DataObject> {
 395
 396         private final DataModification<InstanceIdentifier<?>, DataObject> modification;
 397
 398         @Override
 399         public DataModification<InstanceIdentifier<?>, DataObject> getModification() {
 400             return modification;
 401         }
 402
 403         public internalTransaction(DataModification<InstanceIdentifier<?>, DataObject> modification) {
 404             this.modification = modification;
 405         }
 406
 407         Map<InstanceIdentifier<?>, Meter> additions = new HashMap<>();
 408         Map<InstanceIdentifier<?>, Meter> updates = new HashMap<>();
 409         Set<InstanceIdentifier<?>> removals = new HashSet<>();
 410
 411         /**
 412          * We create a plan which flows will be added, which will be updated and
 413          * which will be removed based on our internal state.
 414          *
 415          */
 416         void prepareUpdate() {
 417
 418             Set<Entry<InstanceIdentifier<?>, DataObject>> puts = modification.getUpdatedConfigurationData().entrySet();
 419             for (Entry<InstanceIdentifier<?>, DataObject> entry : puts) {
 420                 if (entry.getValue() instanceof Meter) {
 421                     Meter Meter = (Meter) entry.getValue();
 422                     preparePutEntry(entry.getKey(), Meter);
 423                 }
 424
 425             }
 426
 427             removals = modification.getRemovedConfigurationData();
 428         }
 429
 430         private void preparePutEntry(InstanceIdentifier<?> key, Meter meter) {
 431
 432             Meter original = originalSwMeterView.get(key);
 433             if (original != null) {
 434                 // It is update for us
 435
 436                 updates.put(key, meter);
 437             } else {
 438                 // It is addition for us
 439
 440                 additions.put(key, meter);
 441             }
 442         }
 443
 444         /**
 445          * We are OK to go with execution of plan
 446          *
 447          */
 448         @Override
 449         public RpcResult<Void> finish() throws IllegalStateException {
 450
 451             RpcResult<Void> rpcStatus = commitToPlugin(this);
 452             // We return true if internal transaction is successful.
 453             // return Rpcs.getRpcResult(true, null, Collections.emptySet());
 454             return rpcStatus;
 455         }
 456
 457         /**
 458          *
 459          * We should rollback our preparation
 460          *
 461          */
 462         @Override
 463         public RpcResult<Void> rollback() throws IllegalStateException {
 464             // NOOP - we did not modified any internal state during
 465             // requestCommit phase
 466             // return Rpcs.getRpcResult(true, null, Collections.emptySet());
 467             return Rpcs.getRpcResult(true, null, null);
 468
 469         }
 470
 471     }
 472
 473     private final class MeterDataCommitHandler implements DataCommitHandler<InstanceIdentifier<?>, DataObject> {
 474         @Override
 475         public org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction<InstanceIdentifier<?>, DataObject> requestCommit(
 476                 DataModification<InstanceIdentifier<?>, DataObject> modification) {
 477             // We should verify transaction
 478             System.out.println("Coming in MeterDataCommitHandler");
 479             internalTransaction transaction = new internalTransaction(modification);
 480             transaction.prepareUpdate();
 481             return transaction;
 482         }
 483     }
 484
 485     final class MeterEventListener implements SalMeterListener {
 486
 487         List<MeterAdded> addedMeter = new ArrayList<>();
 488         List<MeterRemoved> removeMeter = new ArrayList<>();
 489         List<MeterUpdated> updatedMeter = new ArrayList<>();
 490
 491         @Override
 492         public void onMeterAdded(MeterAdded notification) {
 493             // TODO Auto-generated method stub
 494
 495         }
 496
 497         @Override
 498         public void onMeterRemoved(MeterRemoved notification) {
 499             // TODO Auto-generated method stub
 500
 501         }
 502
 503         @Override
 504         public void onMeterUpdated(MeterUpdated notification) {
 505             // TODO Auto-generated method stub
 506
 507         }
 508     }
 509 }