test-provider/src/main/java/org/opendaylight/openflowplugin/test/OpenflowpluginMeterTestCommandProvider.java

   1 /*
   2  * Copyright (c) 2013, 2015 IBM Corporation and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.openflowplugin.test;
   9
  10 import com.google.common.util.concurrent.FutureCallback;
  11 import com.google.common.util.concurrent.MoreExecutors;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import org.eclipse.osgi.framework.console.CommandInterpreter;
  15 import org.eclipse.osgi.framework.console.CommandProvider;
  16 import org.opendaylight.mdsal.binding.api.DataBroker;
  17 import org.opendaylight.mdsal.binding.api.NotificationService;
  18 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
  19 import org.opendaylight.mdsal.common.api.CommitInfo;
  20 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterKey;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  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.types.rev130918.BandId;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterBandType;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterFlags;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.DscpRemarkBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.MeterBandHeadersBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeader;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeaderBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.meter.band.header.MeterBandTypesBuilder;
  43 import org.opendaylight.yangtools.concepts.Registration;
  44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  45 import org.opendaylight.yangtools.yang.common.Uint32;
  46 import org.opendaylight.yangtools.yang.common.Uint8;
  47 import org.osgi.framework.BundleContext;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 @SuppressWarnings("checkstyle:MethodName")
  52 public class OpenflowpluginMeterTestCommandProvider implements CommandProvider {
  53
  54     private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginMeterTestCommandProvider.class);
  55     private final DataBroker dataBroker;
  56     private final BundleContext ctx;
  57     private Meter testMeter;
  58     private Meter testMeter1;
  59     private Meter testMeter2;
  60     private Node testNode;
  61     private final String originalMeterName = "Foo";
  62     private final String updatedMeterName = "Bar";
  63     private final MeterEventListener meterEventListener = new MeterEventListener();
  64     private final NotificationService notificationService;
  65     private Registration listener1Reg;
  66
  67     public OpenflowpluginMeterTestCommandProvider(DataBroker dataBroker, NotificationService notificationService,
  68             BundleContext ctx) {
  69         this.dataBroker = dataBroker;
  70         this.notificationService = notificationService;
  71         this.ctx = ctx;
  72     }
  73
  74     public void init() {
  75         ctx.registerService(CommandProvider.class.getName(), this, null);
  76         // For switch events
  77         listener1Reg = notificationService.registerNotificationListener(meterEventListener);
  78
  79         createTestNode();
  80         createTestMeter();
  81     }
  82
  83     private void createUserNode(String nodeRef) {
  84         NodeBuilder builder = new NodeBuilder();
  85         builder.setId(new NodeId(nodeRef));
  86         builder.withKey(new NodeKey(builder.getId()));
  87         testNode = builder.build();
  88     }
  89
  90     private void createTestNode() {
  91         NodeBuilder builder = new NodeBuilder();
  92         builder.setId(new NodeId(OpenflowpluginTestActivator.NODE_ID));
  93         builder.withKey(new NodeKey(builder.getId()));
  94         testNode = builder.build();
  95     }
  96
  97     private static InstanceIdentifier<Node> nodeToInstanceId(Node node) {
  98         return InstanceIdentifier.create(Nodes.class).child(Node.class, node.key());
  99     }
 100
 101     private static final class MeterEventListener implements SalMeterListener {
 102
 103         @Override
 104         public void onMeterAdded(MeterAdded notification) {
 105             LOG.info("Meter to be added {}", notification.toString());
 106             LOG.info("Meter  Xid {}", notification.getTransactionId().getValue());
 107         }
 108
 109         @Override
 110         public void onMeterRemoved(MeterRemoved notification) {
 111             LOG.info("Meter to be removed {}", notification.toString());
 112             LOG.info("Meter  Xid {}", notification.getTransactionId().getValue());
 113         }
 114
 115         @Override
 116         public void onMeterUpdated(MeterUpdated notification) {
 117             LOG.info("Meter to be updated {}", notification.toString());
 118             LOG.info("Meter  Xid {}", notification.getTransactionId().getValue());
 119         }
 120
 121     }
 122
 123     private MeterBuilder createTestMeter() {
 124         // Sample data , committing to DataStore
 125
 126         MeterKey key = new MeterKey(new MeterId(Uint32.valueOf(12)));
 127         MeterBuilder meter = new MeterBuilder();
 128         meter.setContainerName("abcd");
 129         meter.withKey(key);
 130         meter.setMeterId(new MeterId(Uint32.valueOf(9)));
 131         meter.setMeterName(originalMeterName);
 132         meter.setFlags(new MeterFlags(true, false, false, false));
 133         MeterBandHeaderBuilder bandHeader = new MeterBandHeaderBuilder();
 134         bandHeader.setBandRate(Uint32.valueOf(234));
 135         bandHeader.setBandBurstSize(Uint32.valueOf(444));
 136         DscpRemarkBuilder dscpRemark = new DscpRemarkBuilder();
 137         dscpRemark.setDscpRemarkBurstSize(Uint32.valueOf(5));
 138         dscpRemark.setPrecLevel(Uint8.ONE);
 139         dscpRemark.setDscpRemarkRate(Uint32.valueOf(12));
 140         bandHeader.setBandType(dscpRemark.build());
 141         MeterBandTypesBuilder bandTypes = new MeterBandTypesBuilder();
 142         MeterBandType bandType = new MeterBandType(false, true, false);
 143         bandTypes.setFlags(bandType);
 144         bandHeader.setMeterBandTypes(bandTypes.build());
 145         bandHeader.setBandId(new BandId(Uint32.ZERO));
 146
 147         List<MeterBandHeader> bandHdr = new ArrayList<>();
 148         bandHdr.add(bandHeader.build());
 149
 150         MeterBandHeadersBuilder bandHeaders = new MeterBandHeadersBuilder();
 151         bandHeaders.setMeterBandHeader(bandHdr);
 152         meter.setMeterBandHeaders(bandHeaders.build());
 153
 154         testMeter = meter.build();
 155         return meter;
 156     }
 157
 158     private MeterBuilder createTestMeters(String s1, String s2) {
 159         // Sample data , committing to DataStore
 160         MeterKey key = new MeterKey(new MeterId(Uint32.valueOf(s1)));
 161         MeterBuilder meter = new MeterBuilder();
 162         meter.setContainerName("abcd");
 163         meter.withKey(key);
 164         meter.setMeterId(new MeterId(Uint32.valueOf(9)));
 165         MeterBandHeaderBuilder bandHeader = new MeterBandHeaderBuilder();
 166         if (s2.equalsIgnoreCase("modify")) {
 167             meter.setMeterName(updatedMeterName);
 168             bandHeader.setBandRate(Uint32.valueOf(234));
 169         } else {
 170             meter.setMeterName(originalMeterName);
 171             bandHeader.setBandRate(Uint32.valueOf(123));
 172         }
 173         meter.setFlags(new MeterFlags(true, false, false, false));
 174
 175         bandHeader.setBandBurstSize(Uint32.valueOf(444));
 176         DscpRemarkBuilder dscpRemark = new DscpRemarkBuilder();
 177         dscpRemark.setDscpRemarkBurstSize(Uint32.valueOf(5));
 178         dscpRemark.setPrecLevel(Uint8.ONE);
 179         dscpRemark.setDscpRemarkRate(Uint32.valueOf(12));
 180         bandHeader.setBandType(dscpRemark.build());
 181         MeterBandTypesBuilder bandTypes = new MeterBandTypesBuilder();
 182         MeterBandType bandType = new MeterBandType(false, true, false);
 183         bandTypes.setFlags(bandType);
 184         bandHeader.setMeterBandTypes(bandTypes.build());
 185         bandHeader.setBandId(new BandId(Uint32.ZERO));
 186
 187         List<MeterBandHeader> bandHdr = new ArrayList<>();
 188         bandHdr.add(bandHeader.build());
 189
 190         MeterBandHeadersBuilder bandHeaders = new MeterBandHeadersBuilder();
 191         bandHeaders.setMeterBandHeader(bandHdr);
 192         meter.setMeterBandHeaders(bandHeaders.build());
 193
 194         int firstInt = Integer.parseInt(s1);
 195         switch (firstInt) {
 196             case 1:
 197             case 3:
 198             case 5:
 199             case 7:
 200                 testMeter1 = meter.build();
 201                 break;
 202             case 2:
 203             case 4:
 204             case 6:
 205             case 8:
 206                 testMeter2 = meter.build();
 207                 break;
 208             default:
 209                 // No-op?
 210         }
 211
 212         return meter;
 213     }
 214
 215     public void _removeMeter(final CommandInterpreter ci) {
 216         String nref = ci.nextArgument();
 217
 218         if (nref == null) {
 219             ci.println("test node added");
 220             createTestNode();
 221         } else {
 222             ci.println("User node added" + nref);
 223             createUserNode(nref);
 224         }
 225         createTestMeter();
 226         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 227         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 228                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(testMeter.getMeterId()));
 229         modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
 230         modification.commit().addCallback(new FutureCallback<CommitInfo>() {
 231             @Override
 232             public void onSuccess(CommitInfo notUsed) {
 233                 ci.println("Status of Group Data Loaded Transaction: success.");
 234             }
 235
 236             @Override
 237             public void onFailure(Throwable throwable) {
 238                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 239             }
 240         }, MoreExecutors.directExecutor());
 241     }
 242
 243     public void _removeMeters(final CommandInterpreter ci) {
 244         String nref = ci.nextArgument();
 245
 246         if (nref == null) {
 247             ci.println("test node added");
 248             createTestNode();
 249         } else {
 250             ci.println("User node added" + nref);
 251             createUserNode(nref);
 252         }
 253
 254         int count = Integer.parseInt(ci.nextArgument());
 255
 256         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 257         switch (count) {
 258             case 1:
 259                 createTestMeters("1", "remove");
 260                 InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class)
 261                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 262                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 263                 modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
 264                 createTestMeters("2", "remove");
 265                 InstanceIdentifier<Meter> path2 = InstanceIdentifier.create(Nodes.class)
 266                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 267                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 268                 modification.delete(LogicalDatastoreType.CONFIGURATION, path2);
 269
 270                 break;
 271             case 2:
 272                 createTestMeters("3", "remove");
 273                 InstanceIdentifier<Meter> path3 = InstanceIdentifier.create(Nodes.class)
 274                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 275                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 276                 modification.delete(LogicalDatastoreType.CONFIGURATION, path3);
 277                 createTestMeters("4", "remove");
 278                 InstanceIdentifier<Meter> path4 = InstanceIdentifier.create(Nodes.class)
 279                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 280                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 281                 modification.delete(LogicalDatastoreType.CONFIGURATION, path4);
 282                 break;
 283             case 3:
 284                 createTestMeters("5", "remove");
 285                 InstanceIdentifier<Meter> path5 = InstanceIdentifier.create(Nodes.class)
 286                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 287                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 288                 modification.delete(LogicalDatastoreType.CONFIGURATION, path5);
 289                 createTestMeters("6", "remove");
 290                 InstanceIdentifier<Meter> path6 = InstanceIdentifier.create(Nodes.class)
 291                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 292                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 293                 modification.delete(LogicalDatastoreType.CONFIGURATION, path6);
 294                 break;
 295             case 4:
 296                 createTestMeters("7", "remove");
 297                 InstanceIdentifier<Meter> path7 = InstanceIdentifier.create(Nodes.class)
 298                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 299                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 300                 modification.delete(LogicalDatastoreType.CONFIGURATION, path7);
 301                 createTestMeters("8", "remove");
 302                 InstanceIdentifier<Meter> path8 = InstanceIdentifier.create(Nodes.class)
 303                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 304                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 305                 modification.delete(LogicalDatastoreType.CONFIGURATION, path8);
 306                 break;
 307             default:
 308                 break;
 309         }
 310
 311         modification.commit().addCallback(new FutureCallback<CommitInfo>() {
 312             @Override
 313             public void onSuccess(CommitInfo notUsed) {
 314                 ci.println("Status of Group Data Loaded Transaction: success.");
 315             }
 316
 317             @Override
 318             public void onFailure(Throwable throwable) {
 319                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 320             }
 321         }, MoreExecutors.directExecutor());
 322     }
 323
 324     public void _addMeter(CommandInterpreter ci) {
 325         String nref = ci.nextArgument();
 326
 327         if (nref == null) {
 328             ci.println("test node added");
 329             createTestNode();
 330         } else {
 331             ci.println("User node added" + nref);
 332             createUserNode(nref);
 333         }
 334         createTestMeter();
 335         writeMeter(ci, testMeter);
 336     }
 337
 338     public void _addMeters(CommandInterpreter ci) {
 339         String nref = ci.nextArgument();
 340
 341         if (nref == null) {
 342             ci.println("test node added");
 343             createTestNode();
 344         } else {
 345             ci.println("User node added" + nref);
 346             createUserNode(nref);
 347         }
 348         int count = Integer.parseInt(ci.nextArgument());
 349         switch (count) {
 350             case 1:
 351                 createTestMeters("1", "add");
 352                 createTestMeters("2", "add");
 353                 writeMeter(ci, testMeter1, testMeter2);
 354                 break;
 355             case 2:
 356                 createTestMeters("3", "add");
 357                 createTestMeters("4", "add");
 358                 writeMeter(ci, testMeter1, testMeter2);
 359                 break;
 360             case 3:
 361                 createTestMeters("5", "add");
 362                 createTestMeters("6", "add");
 363                 writeMeter(ci, testMeter1, testMeter2);
 364                 break;
 365             case 4:
 366                 createTestMeters("7", "add");
 367                 createTestMeters("8", "add");
 368                 writeMeter(ci, testMeter1, testMeter2);
 369                 break;
 370             default:
 371                 break;
 372         }
 373         // createTestMeters();
 374         // writeMeter(ci, testMeter);
 375     }
 376
 377     private void writeMeter(final CommandInterpreter ci, Meter meter) {
 378         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 379         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 380                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
 381         modification.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode),
 382                 testNode);
 383         modification.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, path1, meter);
 384         modification.commit().addCallback(new FutureCallback<CommitInfo>() {
 385             @Override
 386             public void onSuccess(CommitInfo notUsed) {
 387                 ci.println("Status of Group Data Loaded Transaction: success.");
 388             }
 389
 390             @Override
 391             public void onFailure(Throwable throwable) {
 392                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 393             }
 394         }, MoreExecutors.directExecutor());
 395     }
 396
 397     private void writeMeter(final CommandInterpreter ci, Meter meter, Meter meter1) {
 398         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 399         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 400                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
 401         modification.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode),
 402                 testNode);
 403         modification.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, path1, meter);
 404         InstanceIdentifier<Meter> path2 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 405                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter1.getMeterId()));
 406         modification.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode),
 407                 testNode);
 408         modification.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, path2, meter1);
 409
 410         modification.commit().addCallback(new FutureCallback<CommitInfo>() {
 411             @Override
 412             public void onSuccess(CommitInfo notUsed) {
 413                 ci.println("Status of Group Data Loaded Transaction: success.");
 414             }
 415
 416             @Override
 417             public void onFailure(Throwable throwable) {
 418                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 419             }
 420         }, MoreExecutors.directExecutor());
 421     }
 422
 423     public void _modifyMeter(CommandInterpreter ci) {
 424         String nref = ci.nextArgument();
 425
 426         if (nref == null) {
 427             ci.println("test node added");
 428             createTestNode();
 429         } else {
 430             ci.println("User node added" + nref);
 431             createUserNode(nref);
 432         }
 433         MeterBuilder meter = createTestMeter();
 434         meter.setMeterName(updatedMeterName);
 435         writeMeter(ci, meter.build());
 436         meter.setMeterName(originalMeterName);
 437         writeMeter(ci, meter.build());
 438     }
 439
 440     public void _modifyMeters(CommandInterpreter ci) {
 441         String nref = ci.nextArgument();
 442
 443         if (nref == null) {
 444             ci.println("test node added");
 445             createTestNode();
 446         } else {
 447             ci.println("User node added" + nref);
 448             createUserNode(nref);
 449         }
 450
 451         int count = Integer.parseInt(ci.nextArgument());
 452         switch (count) {
 453             case 1:
 454                 createTestMeters("1", "modify");
 455                 createTestMeters("2", "modify");
 456                 writeMeter(ci, testMeter1, testMeter2);
 457                 break;
 458             case 2:
 459                 createTestMeters("3", "modify");
 460                 createTestMeters("4", "modify");
 461                 writeMeter(ci, testMeter1, testMeter2);
 462                 break;
 463             default:
 464                 break;
 465         }
 466     }
 467
 468     @Override
 469     public String getHelp() {
 470         StringBuilder help = new StringBuilder();
 471         help.append("---FRM MD-SAL Meter test module---\n");
 472         help.append("\t addMeter <node id>           - node ref\n");
 473         help.append("\t modifyMeter <node id>        - node ref\n");
 474         help.append("\t removeMeter <node id>        - node ref\n");
 475
 476         return help.toString();
 477     }
 478
 479 }