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