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