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