test-provider/src/main/java/org/opendaylight/openflowplugin/test/OpenflowpluginMeterTestCommandProvider.java

   1 /**
   2  * Copyright IBM Corporation, 2013.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.openflowplugin.test;
   9
  10 import com.google.common.util.concurrent.CheckedFuture;
  11 import com.google.common.util.concurrent.FutureCallback;
  12 import com.google.common.util.concurrent.Futures;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import org.eclipse.osgi.framework.console.CommandInterpreter;
  16 import org.eclipse.osgi.framework.console.CommandProvider;
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  20 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  21 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  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 public class OpenflowpluginMeterTestCommandProvider implements CommandProvider {
  52
  53     private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginMeterTestCommandProvider.class);
  54     private DataBroker dataBroker;
  55     private ProviderContext pc;
  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 static NotificationService notificationService;
  65     private Registration listener1Reg;
  66
  67     public OpenflowpluginMeterTestCommandProvider(BundleContext ctx) {
  68         this.ctx = ctx;
  69     }
  70
  71     public void onSessionInitiated(ProviderContext session) {
  72         pc = session;
  73         dataBroker = session.getSALService(DataBroker.class);
  74         ctx.registerService(CommandProvider.class.getName(), this, null);
  75         notificationService = session.getSALService(NotificationService.class);
  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.setKey(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.setKey(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.getKey());
  99     }
 100
 101     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             LOG.info("-----------------------------------------------------------------------------------");
 108         }
 109
 110         @Override
 111         public void onMeterRemoved(MeterRemoved notification) {
 112             LOG.info("Meter to be removed.........................." + notification.toString());
 113             LOG.info("Meter  Xid........................." + notification.getTransactionId().getValue());
 114             LOG.info("-----------------------------------------------------------------------------------");
 115         }
 116
 117         @Override
 118         public void onMeterUpdated(MeterUpdated notification) {
 119             LOG.info("Meter to be updated.........................." + notification.toString());
 120             LOG.info("Meter  Xid........................." + notification.getTransactionId().getValue());
 121             LOG.info("-----------------------------------------------------------------------------------");
 122         }
 123
 124     }
 125
 126     private MeterBuilder createTestMeter() {
 127         // Sample data , committing to DataStore
 128
 129         long id = 12;
 130         MeterKey key = new MeterKey(new MeterId(id));
 131         MeterBuilder meter = new MeterBuilder();
 132         meter.setContainerName("abcd");
 133         meter.setKey(key);
 134         meter.setMeterId(new MeterId(9L));
 135         meter.setMeterName(originalMeterName);
 136         meter.setFlags(new MeterFlags(true, false, false, false));
 137         MeterBandHeadersBuilder bandHeaders = new MeterBandHeadersBuilder();
 138         List<MeterBandHeader> bandHdr = new ArrayList<MeterBandHeader>();
 139         MeterBandHeaderBuilder bandHeader = new MeterBandHeaderBuilder();
 140         bandHeader.setBandRate((long) 234);
 141         bandHeader.setBandBurstSize((long) 444);
 142         DscpRemarkBuilder dscpRemark = new DscpRemarkBuilder();
 143         dscpRemark.setDscpRemarkBurstSize((long) 5);
 144         dscpRemark.setPrecLevel((short) 1);
 145         dscpRemark.setDscpRemarkRate((long) 12);
 146         bandHeader.setBandType(dscpRemark.build());
 147         MeterBandTypesBuilder bandTypes = new MeterBandTypesBuilder();
 148         MeterBandType bandType = new MeterBandType(false, true, false);
 149         bandTypes.setFlags(bandType);
 150         bandHeader.setMeterBandTypes(bandTypes.build());
 151         bandHeader.setBandId(new BandId(0L));
 152         bandHdr.add(bandHeader.build());
 153         bandHeaders.setMeterBandHeader(bandHdr);
 154         meter.setMeterBandHeaders(bandHeaders.build());
 155
 156         testMeter = meter.build();
 157         return meter;
 158     }
 159
 160     private MeterBuilder createTestMeters(String s1, String s2) {
 161         // Sample data , committing to DataStore
 162         long id = Integer.parseInt(s1);
 163         MeterKey key = new MeterKey(new MeterId(id));
 164         MeterBuilder meter = new MeterBuilder();
 165         meter.setContainerName("abcd");
 166         meter.setKey(key);
 167         meter.setMeterId(new MeterId(9L));
 168         MeterBandHeaderBuilder bandHeader = new MeterBandHeaderBuilder();
 169         if (s2.equalsIgnoreCase("modify")) {
 170             meter.setMeterName(updatedMeterName);
 171             bandHeader.setBandRate((long) 234);
 172         } else {
 173             meter.setMeterName(originalMeterName);
 174             bandHeader.setBandRate((long) 123);
 175         }
 176         meter.setFlags(new MeterFlags(true, false, false, false));
 177         MeterBandHeadersBuilder bandHeaders = new MeterBandHeadersBuilder();
 178         List<MeterBandHeader> bandHdr = new ArrayList<MeterBandHeader>();
 179
 180         bandHeader.setBandBurstSize((long) 444);
 181         DscpRemarkBuilder dscpRemark = new DscpRemarkBuilder();
 182         dscpRemark.setDscpRemarkBurstSize((long) 5);
 183         dscpRemark.setPrecLevel((short) 1);
 184         dscpRemark.setDscpRemarkRate((long) 12);
 185         bandHeader.setBandType(dscpRemark.build());
 186         MeterBandTypesBuilder bandTypes = new MeterBandTypesBuilder();
 187         MeterBandType bandType = new MeterBandType(false, true, false);
 188         bandTypes.setFlags(bandType);
 189         bandHeader.setMeterBandTypes(bandTypes.build());
 190         bandHeader.setBandId(new BandId(0L));
 191         bandHdr.add(bandHeader.build());
 192         bandHeaders.setMeterBandHeader(bandHdr);
 193         meter.setMeterBandHeaders(bandHeaders.build());
 194
 195         if (Integer.parseInt(s1) == 1) {
 196             testMeter1 = meter.build();
 197         } else if (Integer.parseInt(s1) == 2) {
 198             testMeter2 = meter.build();
 199         } else if (Integer.parseInt(s1) == 3) {
 200             testMeter1 = meter.build();
 201         } else if (Integer.parseInt(s1) == 4) {
 202             testMeter2 = meter.build();
 203         } else if (Integer.parseInt(s1) == 5) {
 204             testMeter1 = meter.build();
 205         } else if (Integer.parseInt(s1) == 6) {
 206             testMeter2 = meter.build();
 207         } else if (Integer.parseInt(s1) == 7) {
 208             testMeter1 = meter.build();
 209         } else if (Integer.parseInt(s1) == 8) {
 210             testMeter2 = meter.build();
 211         }
 212
 213         return meter;
 214     }
 215
 216     public void _removeMeter(final CommandInterpreter ci) {
 217         String nref = ci.nextArgument();
 218
 219         if (nref == null) {
 220             ci.println("test node added");
 221             createTestNode();
 222         } else {
 223             ci.println("User node added" + nref);
 224             createUserNode(nref);
 225         }
 226         MeterBuilder mBuilder = createTestMeter();
 227         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 228         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.getKey())
 229                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(testMeter.getMeterId()));
 230         modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
 231         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
 232         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 233             @Override
 234             public void onSuccess(Void aVoid) {
 235                 ci.println("Status of Group Data Loaded Transaction: success.");
 236             }
 237
 238             @Override
 239             public void onFailure(Throwable throwable) {
 240                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 241             }
 242         });
 243     }
 244
 245     public void _removeMeters(final CommandInterpreter ci) {
 246         String nref = ci.nextArgument();
 247
 248         if (nref == null) {
 249             ci.println("test node added");
 250             createTestNode();
 251         } else {
 252             ci.println("User node added" + nref);
 253             createUserNode(nref);
 254         }
 255
 256         Integer count = Integer.parseInt(ci.nextArgument());
 257
 258         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 259         switch (count) {
 260             case 1:
 261                 MeterBuilder mBuilder = createTestMeters("1", "remove");
 262                 InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class)
 263                         .child(Node.class, testNode.getKey()).augmentation(FlowCapableNode.class)
 264                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 265                 modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
 266                 MeterBuilder mBuilder1 = createTestMeters("2", "remove");
 267                 InstanceIdentifier<Meter> path2 = InstanceIdentifier.create(Nodes.class)
 268                         .child(Node.class, testNode.getKey()).augmentation(FlowCapableNode.class)
 269                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 270                 modification.delete(LogicalDatastoreType.CONFIGURATION, path2);
 271
 272                 break;
 273             case 2:
 274                 MeterBuilder mBuilder2 = createTestMeters("3", "remove");
 275                 InstanceIdentifier<Meter> path3 = InstanceIdentifier.create(Nodes.class)
 276                         .child(Node.class, testNode.getKey()).augmentation(FlowCapableNode.class)
 277                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 278                 modification.delete(LogicalDatastoreType.CONFIGURATION, path3);
 279                 MeterBuilder mBuilder22 = createTestMeters("4", "remove");
 280                 InstanceIdentifier<Meter> path4 = InstanceIdentifier.create(Nodes.class)
 281                         .child(Node.class, testNode.getKey()).augmentation(FlowCapableNode.class)
 282                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 283                 modification.delete(LogicalDatastoreType.CONFIGURATION, path4);
 284                 break;
 285             case 3:
 286                 MeterBuilder mBuilder3 = createTestMeters("5", "remove");
 287                 InstanceIdentifier<Meter> path5 = InstanceIdentifier.create(Nodes.class)
 288                         .child(Node.class, testNode.getKey()).augmentation(FlowCapableNode.class)
 289                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 290                 modification.delete(LogicalDatastoreType.CONFIGURATION, path5);
 291                 MeterBuilder mBuilder4 = createTestMeters("6", "remove");
 292                 InstanceIdentifier<Meter> path6 = InstanceIdentifier.create(Nodes.class)
 293                         .child(Node.class, testNode.getKey()).augmentation(FlowCapableNode.class)
 294                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 295                 modification.delete(LogicalDatastoreType.CONFIGURATION, path6);
 296                 break;
 297             case 4:
 298                 MeterBuilder mBuilder5 = createTestMeters("7", "remove");
 299                 InstanceIdentifier<Meter> path7 = InstanceIdentifier.create(Nodes.class)
 300                         .child(Node.class, testNode.getKey()).augmentation(FlowCapableNode.class)
 301                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 302                 modification.delete(LogicalDatastoreType.CONFIGURATION, path7);
 303                 MeterBuilder mBuilder6 = createTestMeters("8", "remove");
 304                 InstanceIdentifier<Meter> path8 = InstanceIdentifier.create(Nodes.class)
 305                         .child(Node.class, testNode.getKey()).augmentation(FlowCapableNode.class)
 306                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 307                 modification.delete(LogicalDatastoreType.CONFIGURATION, path8);
 308                 break;
 309
 310         }
 311
 312         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
 313         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 314             @Override
 315             public void onSuccess(Void aVoid) {
 316                 ci.println("Status of Group Data Loaded Transaction: success.");
 317             }
 318
 319             @Override
 320             public void onFailure(Throwable throwable) {
 321                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 322             }
 323         });
 324     }
 325
 326     public void _addMeter(CommandInterpreter ci) {
 327         String nref = ci.nextArgument();
 328
 329         if (nref == null) {
 330             ci.println("test node added");
 331             createTestNode();
 332         } else {
 333             ci.println("User node added" + nref);
 334             createUserNode(nref);
 335         }
 336         createTestMeter();
 337         writeMeter(ci, testMeter);
 338     }
 339
 340     public void _addMeters(CommandInterpreter ci) {
 341         String nref = ci.nextArgument();
 342
 343         if (nref == null) {
 344             ci.println("test node added");
 345             createTestNode();
 346         } else {
 347             ci.println("User node added" + nref);
 348             createUserNode(nref);
 349         }
 350         Integer count = Integer.parseInt(ci.nextArgument());
 351         switch (count) {
 352             case 1:
 353                 createTestMeters("1", "add");
 354                 createTestMeters("2", "add");
 355                 writeMeter(ci, testMeter1, testMeter2);
 356                 break;
 357             case 2:
 358                 createTestMeters("3", "add");
 359                 createTestMeters("4", "add");
 360                 writeMeter(ci, testMeter1, testMeter2);
 361                 break;
 362             case 3:
 363                 createTestMeters("5", "add");
 364                 createTestMeters("6", "add");
 365                 writeMeter(ci, testMeter1, testMeter2);
 366                 break;
 367             case 4:
 368                 createTestMeters("7", "add");
 369                 createTestMeters("8", "add");
 370                 writeMeter(ci, testMeter1, testMeter2);
 371                 break;
 372
 373         }
 374         // createTestMeters();
 375         // writeMeter(ci, testMeter);
 376     }
 377
 378     private void writeMeter(final CommandInterpreter ci, Meter meter) {
 379         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 380         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.getKey())
 381                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
 382         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 383         modification.merge(LogicalDatastoreType.CONFIGURATION, path1, meter, true);
 384         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
 385         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 386             @Override
 387             public void onSuccess(Void aVoid) {
 388                 ci.println("Status of Group Data Loaded Transaction: success.");
 389             }
 390
 391             @Override
 392             public void onFailure(Throwable throwable) {
 393                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 394             }
 395         });
 396     }
 397
 398     private void writeMeter(final CommandInterpreter ci, Meter meter, Meter meter1) {
 399         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 400         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.getKey())
 401                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
 402         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 403         modification.merge(LogicalDatastoreType.CONFIGURATION, path1, meter, true);
 404         InstanceIdentifier<Meter> path2 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.getKey())
 405                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter1.getMeterId()));
 406         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 407         modification.merge(LogicalDatastoreType.CONFIGURATION, path2, meter1, true);
 408
 409         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
 410         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 411             @Override
 412             public void onSuccess(Void aVoid) {
 413                 ci.println("Status of Group Data Loaded Transaction: success.");
 414             }
 415
 416             @Override
 417             public void onFailure(Throwable throwable) {
 418                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 419             }
 420         });
 421     }
 422
 423     public void _modifyMeter(CommandInterpreter ci) {
 424         String nref = ci.nextArgument();
 425
 426         if (nref == null) {
 427             ci.println("test node added");
 428             createTestNode();
 429         } else {
 430             ci.println("User node added" + nref);
 431             createUserNode(nref);
 432         }
 433         MeterBuilder meter = createTestMeter();
 434         meter.setMeterName(updatedMeterName);
 435         writeMeter(ci, meter.build());
 436         meter.setMeterName(originalMeterName);
 437         writeMeter(ci, meter.build());
 438     }
 439
 440     public void _modifyMeters(CommandInterpreter ci) {
 441         String nref = ci.nextArgument();
 442
 443         if (nref == null) {
 444             ci.println("test node added");
 445             createTestNode();
 446         } else {
 447             ci.println("User node added" + nref);
 448             createUserNode(nref);
 449         }
 450
 451         Integer count = Integer.parseInt(ci.nextArgument());
 452         switch (count) {
 453             case 1:
 454                 createTestMeters("1", "modify");
 455                 createTestMeters("2", "modify");
 456                 writeMeter(ci, testMeter1, testMeter2);
 457                 break;
 458             case 2:
 459                 createTestMeters("3", "modify");
 460                 createTestMeters("4", "modify");
 461                 writeMeter(ci, testMeter1, testMeter2);
 462                 break;
 463         }
 464     }
 465
 466     @Override
 467     public String getHelp() {
 468         StringBuffer help = new StringBuffer();
 469         help.append("---FRM MD-SAL Meter test module---\n");
 470         help.append("\t addMeter <node id>           - node ref\n");
 471         help.append("\t modifyMeter <node id>        - node ref\n");
 472         help.append("\t removeMeter <node id>        - node ref\n");
 473
 474         return help.toString();
 475     }
 476
 477 }