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
   9 package org.opendaylight.openflowplugin.test;
  10
  11 import com.google.common.util.concurrent.FutureCallback;
  12 import com.google.common.util.concurrent.Futures;
  13 import com.google.common.util.concurrent.ListenableFuture;
  14 import com.google.common.util.concurrent.MoreExecutors;
  15 import java.util.ArrayList;
  16 import java.util.List;
  17 import org.eclipse.osgi.framework.console.CommandInterpreter;
  18 import org.eclipse.osgi.framework.console.CommandProvider;
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.controller.sal.binding.api.NotificationService;
  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.inventory.rev130819.nodes.NodeKey;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.MeterAdded;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.MeterRemoved;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.MeterUpdated;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.SalMeterListener;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.BandId;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterBandType;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterFlags;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.DscpRemarkBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.MeterBandHeadersBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeader;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeaderBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.meter.band.header.MeterBandTypesBuilder;
  45 import org.opendaylight.yangtools.concepts.Registration;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  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 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         long id = 12;
 127         MeterKey key = new MeterKey(new MeterId(id));
 128         MeterBuilder meter = new MeterBuilder();
 129         meter.setContainerName("abcd");
 130         meter.withKey(key);
 131         meter.setMeterId(new MeterId(9L));
 132         meter.setMeterName(originalMeterName);
 133         meter.setFlags(new MeterFlags(true, false, false, false));
 134         MeterBandHeaderBuilder bandHeader = new MeterBandHeaderBuilder();
 135         bandHeader.setBandRate((long) 234);
 136         bandHeader.setBandBurstSize((long) 444);
 137         DscpRemarkBuilder dscpRemark = new DscpRemarkBuilder();
 138         dscpRemark.setDscpRemarkBurstSize((long) 5);
 139         dscpRemark.setPrecLevel((short) 1);
 140         dscpRemark.setDscpRemarkRate((long) 12);
 141         bandHeader.setBandType(dscpRemark.build());
 142         MeterBandTypesBuilder bandTypes = new MeterBandTypesBuilder();
 143         MeterBandType bandType = new MeterBandType(false, true, false);
 144         bandTypes.setFlags(bandType);
 145         bandHeader.setMeterBandTypes(bandTypes.build());
 146         bandHeader.setBandId(new BandId(0L));
 147
 148         List<MeterBandHeader> bandHdr = new ArrayList<>();
 149         bandHdr.add(bandHeader.build());
 150
 151         MeterBandHeadersBuilder bandHeaders = new MeterBandHeadersBuilder();
 152         bandHeaders.setMeterBandHeader(bandHdr);
 153         meter.setMeterBandHeaders(bandHeaders.build());
 154
 155         testMeter = meter.build();
 156         return meter;
 157     }
 158
 159     private MeterBuilder createTestMeters(String s1, String s2) {
 160         // Sample data , committing to DataStore
 161         long id = Integer.parseInt(s1);
 162         MeterKey key = new MeterKey(new MeterId(id));
 163         MeterBuilder meter = new MeterBuilder();
 164         meter.setContainerName("abcd");
 165         meter.withKey(key);
 166         meter.setMeterId(new MeterId(9L));
 167         MeterBandHeaderBuilder bandHeader = new MeterBandHeaderBuilder();
 168         if (s2.equalsIgnoreCase("modify")) {
 169             meter.setMeterName(updatedMeterName);
 170             bandHeader.setBandRate((long) 234);
 171         } else {
 172             meter.setMeterName(originalMeterName);
 173             bandHeader.setBandRate((long) 123);
 174         }
 175         meter.setFlags(new MeterFlags(true, false, false, false));
 176
 177         bandHeader.setBandBurstSize((long) 444);
 178         DscpRemarkBuilder dscpRemark = new DscpRemarkBuilder();
 179         dscpRemark.setDscpRemarkBurstSize((long) 5);
 180         dscpRemark.setPrecLevel((short) 1);
 181         dscpRemark.setDscpRemarkRate((long) 12);
 182         bandHeader.setBandType(dscpRemark.build());
 183         MeterBandTypesBuilder bandTypes = new MeterBandTypesBuilder();
 184         MeterBandType bandType = new MeterBandType(false, true, false);
 185         bandTypes.setFlags(bandType);
 186         bandHeader.setMeterBandTypes(bandTypes.build());
 187         bandHeader.setBandId(new BandId(0L));
 188
 189         List<MeterBandHeader> bandHdr = new ArrayList<>();
 190         bandHdr.add(bandHeader.build());
 191
 192         MeterBandHeadersBuilder bandHeaders = new MeterBandHeadersBuilder();
 193         bandHeaders.setMeterBandHeader(bandHdr);
 194         meter.setMeterBandHeaders(bandHeaders.build());
 195
 196         if (Integer.parseInt(s1) == 1) {
 197             testMeter1 = meter.build();
 198         } else if (Integer.parseInt(s1) == 2) {
 199             testMeter2 = meter.build();
 200         } else if (Integer.parseInt(s1) == 3) {
 201             testMeter1 = meter.build();
 202         } else if (Integer.parseInt(s1) == 4) {
 203             testMeter2 = meter.build();
 204         } else if (Integer.parseInt(s1) == 5) {
 205             testMeter1 = meter.build();
 206         } else if (Integer.parseInt(s1) == 6) {
 207             testMeter2 = meter.build();
 208         } else if (Integer.parseInt(s1) == 7) {
 209             testMeter1 = meter.build();
 210         } else if (Integer.parseInt(s1) == 8) {
 211             testMeter2 = meter.build();
 212         }
 213
 214         return meter;
 215     }
 216
 217     public void _removeMeter(final CommandInterpreter ci) {
 218         String nref = ci.nextArgument();
 219
 220         if (nref == null) {
 221             ci.println("test node added");
 222             createTestNode();
 223         } else {
 224             ci.println("User node added" + nref);
 225             createUserNode(nref);
 226         }
 227         createTestMeter();
 228         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 229         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 230                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(testMeter.getMeterId()));
 231         modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
 232         ListenableFuture<Void> commitFuture = modification.submit();
 233         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 234             @Override
 235             public void onSuccess(Void notUsed) {
 236                 ci.println("Status of Group Data Loaded Transaction: success.");
 237             }
 238
 239             @Override
 240             public void onFailure(Throwable throwable) {
 241                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 242             }
 243         }, MoreExecutors.directExecutor());
 244     }
 245
 246     public void _removeMeters(final CommandInterpreter ci) {
 247         String nref = ci.nextArgument();
 248
 249         if (nref == null) {
 250             ci.println("test node added");
 251             createTestNode();
 252         } else {
 253             ci.println("User node added" + nref);
 254             createUserNode(nref);
 255         }
 256
 257         Integer count = Integer.parseInt(ci.nextArgument());
 258
 259         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 260         switch (count) {
 261             case 1:
 262                 createTestMeters("1", "remove");
 263                 InstanceIdentifier<Meter> path1 = 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, path1);
 267                 createTestMeters("2", "remove");
 268                 InstanceIdentifier<Meter> path2 = 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, path2);
 272
 273                 break;
 274             case 2:
 275                 createTestMeters("3", "remove");
 276                 InstanceIdentifier<Meter> path3 = InstanceIdentifier.create(Nodes.class)
 277                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 278                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 279                 modification.delete(LogicalDatastoreType.CONFIGURATION, path3);
 280                 createTestMeters("4", "remove");
 281                 InstanceIdentifier<Meter> path4 = InstanceIdentifier.create(Nodes.class)
 282                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 283                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 284                 modification.delete(LogicalDatastoreType.CONFIGURATION, path4);
 285                 break;
 286             case 3:
 287                 createTestMeters("5", "remove");
 288                 InstanceIdentifier<Meter> path5 = InstanceIdentifier.create(Nodes.class)
 289                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 290                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 291                 modification.delete(LogicalDatastoreType.CONFIGURATION, path5);
 292                 createTestMeters("6", "remove");
 293                 InstanceIdentifier<Meter> path6 = InstanceIdentifier.create(Nodes.class)
 294                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 295                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 296                 modification.delete(LogicalDatastoreType.CONFIGURATION, path6);
 297                 break;
 298             case 4:
 299                 createTestMeters("7", "remove");
 300                 InstanceIdentifier<Meter> path7 = InstanceIdentifier.create(Nodes.class)
 301                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 302                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 303                 modification.delete(LogicalDatastoreType.CONFIGURATION, path7);
 304                 createTestMeters("8", "remove");
 305                 InstanceIdentifier<Meter> path8 = InstanceIdentifier.create(Nodes.class)
 306                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 307                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 308                 modification.delete(LogicalDatastoreType.CONFIGURATION, path8);
 309                 break;
 310             default:
 311                 break;
 312         }
 313
 314         ListenableFuture<Void> commitFuture = modification.submit();
 315         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 316             @Override
 317             public void onSuccess(Void notUsed) {
 318                 ci.println("Status of Group Data Loaded Transaction: success.");
 319             }
 320
 321             @Override
 322             public void onFailure(Throwable throwable) {
 323                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 324             }
 325         }, MoreExecutors.directExecutor());
 326     }
 327
 328     public void _addMeter(CommandInterpreter ci) {
 329         String nref = ci.nextArgument();
 330
 331         if (nref == null) {
 332             ci.println("test node added");
 333             createTestNode();
 334         } else {
 335             ci.println("User node added" + nref);
 336             createUserNode(nref);
 337         }
 338         createTestMeter();
 339         writeMeter(ci, testMeter);
 340     }
 341
 342     public void _addMeters(CommandInterpreter ci) {
 343         String nref = ci.nextArgument();
 344
 345         if (nref == null) {
 346             ci.println("test node added");
 347             createTestNode();
 348         } else {
 349             ci.println("User node added" + nref);
 350             createUserNode(nref);
 351         }
 352         Integer count = Integer.parseInt(ci.nextArgument());
 353         switch (count) {
 354             case 1:
 355                 createTestMeters("1", "add");
 356                 createTestMeters("2", "add");
 357                 writeMeter(ci, testMeter1, testMeter2);
 358                 break;
 359             case 2:
 360                 createTestMeters("3", "add");
 361                 createTestMeters("4", "add");
 362                 writeMeter(ci, testMeter1, testMeter2);
 363                 break;
 364             case 3:
 365                 createTestMeters("5", "add");
 366                 createTestMeters("6", "add");
 367                 writeMeter(ci, testMeter1, testMeter2);
 368                 break;
 369             case 4:
 370                 createTestMeters("7", "add");
 371                 createTestMeters("8", "add");
 372                 writeMeter(ci, testMeter1, testMeter2);
 373                 break;
 374             default:
 375                 break;
 376         }
 377         // createTestMeters();
 378         // writeMeter(ci, testMeter);
 379     }
 380
 381     private void writeMeter(final CommandInterpreter ci, Meter meter) {
 382         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 383         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 384                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
 385         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 386         modification.merge(LogicalDatastoreType.CONFIGURATION, path1, meter, true);
 387         ListenableFuture<Void> commitFuture = modification.submit();
 388         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 389             @Override
 390             public void onSuccess(Void notUsed) {
 391                 ci.println("Status of Group Data Loaded Transaction: success.");
 392             }
 393
 394             @Override
 395             public void onFailure(Throwable throwable) {
 396                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 397             }
 398         }, MoreExecutors.directExecutor());
 399     }
 400
 401     private void writeMeter(final CommandInterpreter ci, Meter meter, Meter meter1) {
 402         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 403         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 404                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
 405         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 406         modification.merge(LogicalDatastoreType.CONFIGURATION, path1, meter, true);
 407         InstanceIdentifier<Meter> path2 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 408                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter1.getMeterId()));
 409         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 410         modification.merge(LogicalDatastoreType.CONFIGURATION, path2, meter1, true);
 411
 412         ListenableFuture<Void> commitFuture = modification.submit();
 413         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 414             @Override
 415             public void onSuccess(Void notUsed) {
 416                 ci.println("Status of Group Data Loaded Transaction: success.");
 417             }
 418
 419             @Override
 420             public void onFailure(Throwable throwable) {
 421                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 422             }
 423         }, MoreExecutors.directExecutor());
 424     }
 425
 426     public void _modifyMeter(CommandInterpreter ci) {
 427         String nref = ci.nextArgument();
 428
 429         if (nref == null) {
 430             ci.println("test node added");
 431             createTestNode();
 432         } else {
 433             ci.println("User node added" + nref);
 434             createUserNode(nref);
 435         }
 436         MeterBuilder meter = createTestMeter();
 437         meter.setMeterName(updatedMeterName);
 438         writeMeter(ci, meter.build());
 439         meter.setMeterName(originalMeterName);
 440         writeMeter(ci, meter.build());
 441     }
 442
 443     public void _modifyMeters(CommandInterpreter ci) {
 444         String nref = ci.nextArgument();
 445
 446         if (nref == null) {
 447             ci.println("test node added");
 448             createTestNode();
 449         } else {
 450             ci.println("User node added" + nref);
 451             createUserNode(nref);
 452         }
 453
 454         Integer count = Integer.parseInt(ci.nextArgument());
 455         switch (count) {
 456             case 1:
 457                 createTestMeters("1", "modify");
 458                 createTestMeters("2", "modify");
 459                 writeMeter(ci, testMeter1, testMeter2);
 460                 break;
 461             case 2:
 462                 createTestMeters("3", "modify");
 463                 createTestMeters("4", "modify");
 464                 writeMeter(ci, testMeter1, testMeter2);
 465                 break;
 466             default:
 467                 break;
 468         }
 469     }
 470
 471     @Override
 472     public String getHelp() {
 473         StringBuilder help = new StringBuilder();
 474         help.append("---FRM MD-SAL Meter test module---\n");
 475         help.append("\t addMeter <node id>           - node ref\n");
 476         help.append("\t modifyMeter <node id>        - node ref\n");
 477         help.append("\t removeMeter <node id>        - node ref\n");
 478
 479         return help.toString();
 480     }
 481
 482 }