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