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