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