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