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.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 @SuppressWarnings("checkstyle:MethodName")
  53 public class OpenflowpluginMeterTestCommandProvider implements CommandProvider {
  54
  55     private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginMeterTestCommandProvider.class);
  56     private DataBroker dataBroker;
  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 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         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.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             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.withKey(key);
 134         meter.setMeterId(new MeterId(9L));
 135         meter.setMeterName(originalMeterName);
 136         meter.setFlags(new MeterFlags(true, false, false, false));
 137         MeterBandHeaderBuilder bandHeader = new MeterBandHeaderBuilder();
 138         bandHeader.setBandRate((long) 234);
 139         bandHeader.setBandBurstSize((long) 444);
 140         DscpRemarkBuilder dscpRemark = new DscpRemarkBuilder();
 141         dscpRemark.setDscpRemarkBurstSize((long) 5);
 142         dscpRemark.setPrecLevel((short) 1);
 143         dscpRemark.setDscpRemarkRate((long) 12);
 144         bandHeader.setBandType(dscpRemark.build());
 145         MeterBandTypesBuilder bandTypes = new MeterBandTypesBuilder();
 146         MeterBandType bandType = new MeterBandType(false, true, false);
 147         bandTypes.setFlags(bandType);
 148         bandHeader.setMeterBandTypes(bandTypes.build());
 149         bandHeader.setBandId(new BandId(0L));
 150
 151         List<MeterBandHeader> bandHdr = new ArrayList<>();
 152         bandHdr.add(bandHeader.build());
 153
 154         MeterBandHeadersBuilder bandHeaders = new MeterBandHeadersBuilder();
 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.withKey(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
 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
 192         List<MeterBandHeader> bandHdr = new ArrayList<>();
 193         bandHdr.add(bandHeader.build());
 194
 195         MeterBandHeadersBuilder bandHeaders = new MeterBandHeadersBuilder();
 196         bandHeaders.setMeterBandHeader(bandHdr);
 197         meter.setMeterBandHeaders(bandHeaders.build());
 198
 199         if (Integer.parseInt(s1) == 1) {
 200             testMeter1 = meter.build();
 201         } else if (Integer.parseInt(s1) == 2) {
 202             testMeter2 = meter.build();
 203         } else if (Integer.parseInt(s1) == 3) {
 204             testMeter1 = meter.build();
 205         } else if (Integer.parseInt(s1) == 4) {
 206             testMeter2 = meter.build();
 207         } else if (Integer.parseInt(s1) == 5) {
 208             testMeter1 = meter.build();
 209         } else if (Integer.parseInt(s1) == 6) {
 210             testMeter2 = meter.build();
 211         } else if (Integer.parseInt(s1) == 7) {
 212             testMeter1 = meter.build();
 213         } else if (Integer.parseInt(s1) == 8) {
 214             testMeter2 = meter.build();
 215         }
 216
 217         return meter;
 218     }
 219
 220     public void _removeMeter(final CommandInterpreter ci) {
 221         String nref = ci.nextArgument();
 222
 223         if (nref == null) {
 224             ci.println("test node added");
 225             createTestNode();
 226         } else {
 227             ci.println("User node added" + nref);
 228             createUserNode(nref);
 229         }
 230         createTestMeter();
 231         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 232         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 233                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(testMeter.getMeterId()));
 234         modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
 235         ListenableFuture<Void> commitFuture = modification.submit();
 236         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 237             @Override
 238             public void onSuccess(Void notUsed) {
 239                 ci.println("Status of Group Data Loaded Transaction: success.");
 240             }
 241
 242             @Override
 243             public void onFailure(Throwable throwable) {
 244                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 245             }
 246         }, MoreExecutors.directExecutor());
 247     }
 248
 249     public void _removeMeters(final CommandInterpreter ci) {
 250         String nref = ci.nextArgument();
 251
 252         if (nref == null) {
 253             ci.println("test node added");
 254             createTestNode();
 255         } else {
 256             ci.println("User node added" + nref);
 257             createUserNode(nref);
 258         }
 259
 260         Integer count = Integer.parseInt(ci.nextArgument());
 261
 262         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 263         switch (count) {
 264             case 1:
 265                 createTestMeters("1", "remove");
 266                 InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class)
 267                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 268                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 269                 modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
 270                 createTestMeters("2", "remove");
 271                 InstanceIdentifier<Meter> path2 = InstanceIdentifier.create(Nodes.class)
 272                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 273                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 274                 modification.delete(LogicalDatastoreType.CONFIGURATION, path2);
 275
 276                 break;
 277             case 2:
 278                 createTestMeters("3", "remove");
 279                 InstanceIdentifier<Meter> path3 = InstanceIdentifier.create(Nodes.class)
 280                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 281                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 282                 modification.delete(LogicalDatastoreType.CONFIGURATION, path3);
 283                 createTestMeters("4", "remove");
 284                 InstanceIdentifier<Meter> path4 = InstanceIdentifier.create(Nodes.class)
 285                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 286                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 287                 modification.delete(LogicalDatastoreType.CONFIGURATION, path4);
 288                 break;
 289             case 3:
 290                 createTestMeters("5", "remove");
 291                 InstanceIdentifier<Meter> path5 = InstanceIdentifier.create(Nodes.class)
 292                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 293                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 294                 modification.delete(LogicalDatastoreType.CONFIGURATION, path5);
 295                 createTestMeters("6", "remove");
 296                 InstanceIdentifier<Meter> path6 = InstanceIdentifier.create(Nodes.class)
 297                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 298                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 299                 modification.delete(LogicalDatastoreType.CONFIGURATION, path6);
 300                 break;
 301             case 4:
 302                 createTestMeters("7", "remove");
 303                 InstanceIdentifier<Meter> path7 = InstanceIdentifier.create(Nodes.class)
 304                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 305                         .child(Meter.class, new MeterKey(testMeter1.getMeterId()));
 306                 modification.delete(LogicalDatastoreType.CONFIGURATION, path7);
 307                 createTestMeters("8", "remove");
 308                 InstanceIdentifier<Meter> path8 = InstanceIdentifier.create(Nodes.class)
 309                         .child(Node.class, testNode.key()).augmentation(FlowCapableNode.class)
 310                         .child(Meter.class, new MeterKey(testMeter2.getMeterId()));
 311                 modification.delete(LogicalDatastoreType.CONFIGURATION, path8);
 312                 break;
 313             default:
 314                 break;
 315         }
 316
 317         ListenableFuture<Void> commitFuture = modification.submit();
 318         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 319             @Override
 320             public void onSuccess(Void notUsed) {
 321                 ci.println("Status of Group Data Loaded Transaction: success.");
 322             }
 323
 324             @Override
 325             public void onFailure(Throwable throwable) {
 326                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 327             }
 328         }, MoreExecutors.directExecutor());
 329     }
 330
 331     public void _addMeter(CommandInterpreter ci) {
 332         String nref = ci.nextArgument();
 333
 334         if (nref == null) {
 335             ci.println("test node added");
 336             createTestNode();
 337         } else {
 338             ci.println("User node added" + nref);
 339             createUserNode(nref);
 340         }
 341         createTestMeter();
 342         writeMeter(ci, testMeter);
 343     }
 344
 345     public void _addMeters(CommandInterpreter ci) {
 346         String nref = ci.nextArgument();
 347
 348         if (nref == null) {
 349             ci.println("test node added");
 350             createTestNode();
 351         } else {
 352             ci.println("User node added" + nref);
 353             createUserNode(nref);
 354         }
 355         Integer count = Integer.parseInt(ci.nextArgument());
 356         switch (count) {
 357             case 1:
 358                 createTestMeters("1", "add");
 359                 createTestMeters("2", "add");
 360                 writeMeter(ci, testMeter1, testMeter2);
 361                 break;
 362             case 2:
 363                 createTestMeters("3", "add");
 364                 createTestMeters("4", "add");
 365                 writeMeter(ci, testMeter1, testMeter2);
 366                 break;
 367             case 3:
 368                 createTestMeters("5", "add");
 369                 createTestMeters("6", "add");
 370                 writeMeter(ci, testMeter1, testMeter2);
 371                 break;
 372             case 4:
 373                 createTestMeters("7", "add");
 374                 createTestMeters("8", "add");
 375                 writeMeter(ci, testMeter1, testMeter2);
 376                 break;
 377             default:
 378                 break;
 379         }
 380         // createTestMeters();
 381         // writeMeter(ci, testMeter);
 382     }
 383
 384     private void writeMeter(final CommandInterpreter ci, Meter meter) {
 385         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 386         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 387                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
 388         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 389         modification.merge(LogicalDatastoreType.CONFIGURATION, path1, meter, true);
 390         ListenableFuture<Void> commitFuture = modification.submit();
 391         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 392             @Override
 393             public void onSuccess(Void notUsed) {
 394                 ci.println("Status of Group Data Loaded Transaction: success.");
 395             }
 396
 397             @Override
 398             public void onFailure(Throwable throwable) {
 399                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 400             }
 401         }, MoreExecutors.directExecutor());
 402     }
 403
 404     private void writeMeter(final CommandInterpreter ci, Meter meter, Meter meter1) {
 405         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 406         InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 407                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
 408         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 409         modification.merge(LogicalDatastoreType.CONFIGURATION, path1, meter, true);
 410         InstanceIdentifier<Meter> path2 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
 411                 .augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter1.getMeterId()));
 412         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
 413         modification.merge(LogicalDatastoreType.CONFIGURATION, path2, meter1, true);
 414
 415         ListenableFuture<Void> commitFuture = modification.submit();
 416         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 417             @Override
 418             public void onSuccess(Void notUsed) {
 419                 ci.println("Status of Group Data Loaded Transaction: success.");
 420             }
 421
 422             @Override
 423             public void onFailure(Throwable throwable) {
 424                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 425             }
 426         }, MoreExecutors.directExecutor());
 427     }
 428
 429     public void _modifyMeter(CommandInterpreter ci) {
 430         String nref = ci.nextArgument();
 431
 432         if (nref == null) {
 433             ci.println("test node added");
 434             createTestNode();
 435         } else {
 436             ci.println("User node added" + nref);
 437             createUserNode(nref);
 438         }
 439         MeterBuilder meter = createTestMeter();
 440         meter.setMeterName(updatedMeterName);
 441         writeMeter(ci, meter.build());
 442         meter.setMeterName(originalMeterName);
 443         writeMeter(ci, meter.build());
 444     }
 445
 446     public void _modifyMeters(CommandInterpreter ci) {
 447         String nref = ci.nextArgument();
 448
 449         if (nref == null) {
 450             ci.println("test node added");
 451             createTestNode();
 452         } else {
 453             ci.println("User node added" + nref);
 454             createUserNode(nref);
 455         }
 456
 457         Integer count = Integer.parseInt(ci.nextArgument());
 458         switch (count) {
 459             case 1:
 460                 createTestMeters("1", "modify");
 461                 createTestMeters("2", "modify");
 462                 writeMeter(ci, testMeter1, testMeter2);
 463                 break;
 464             case 2:
 465                 createTestMeters("3", "modify");
 466                 createTestMeters("4", "modify");
 467                 writeMeter(ci, testMeter1, testMeter2);
 468                 break;
 469             default:
 470                 break;
 471         }
 472     }
 473
 474     @Override
 475     public String getHelp() {
 476         StringBuilder help = new StringBuilder();
 477         help.append("---FRM MD-SAL Meter test module---\n");
 478         help.append("\t addMeter <node id>           - node ref\n");
 479         help.append("\t modifyMeter <node id>        - node ref\n");
 480         help.append("\t removeMeter <node id>        - node ref\n");
 481
 482         return help.toString();
 483     }
 484
 485 }