vpnmanager/shell/src/main/java/org/opendaylight/netvirt/vpnmanager/shell/ShowVpn.java

   1 /*
   2  * Copyright © 2016, 2017 Ericsson India Global Services Pvt Ltd. 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.netvirt.vpnmanager.shell;
   9
  10 import com.google.common.base.Optional;
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Objects;
  17 import java.util.Set;
  18 import java.util.concurrent.ExecutionException;
  19 import org.apache.karaf.shell.commands.Command;
  20 import org.apache.karaf.shell.commands.Option;
  21 import org.apache.karaf.shell.console.OsgiCommandSupport;
  22 import org.eclipse.jdt.annotation.Nullable;
  23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInterfaceOpData;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntry;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInstances;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInterfaces;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.VpnInstance;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
  34 import org.opendaylight.yangtools.yang.binding.DataObject;
  35 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 @Command(scope = "vpnservice", name = "vpn-show", description = "Display all present vpnInstances with their "
  40         + "respective count of oper and config vpnInterfaces")
  41 public class ShowVpn extends OsgiCommandSupport {
  42
  43     @Option(name = "--detail", aliases = {"--vpninstance"}, description = "Display oper and config interfaces for "
  44             + "given vpnInstanceName", required = false, multiValued = false)
  45     private String detail;
  46
  47     private static final Logger LOG = LoggerFactory.getLogger(ShowVpn.class);
  48     private DataBroker dataBroker;
  49     private int configCount = 0;
  50     private int operCount = 0;
  51     private int totalOperCount = 0;
  52     private int totalConfigCount = 0;
  53     private Integer ifPresent;
  54     private List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances
  55             .VpnInstance> vpnInstanceList = new ArrayList<>();
  56     private List<VpnInterface> vpnInterfaceConfigList = new ArrayList<>();
  57     private List<VpnInterfaceOpDataEntry> vpnInterfaceOpList = new ArrayList<>();
  58
  59     public void setDataBroker(DataBroker broker) {
  60         this.dataBroker = broker;
  61     }
  62
  63     @Override
  64     @Nullable
  65     protected Object doExecute() {
  66         Map<String, Integer> vpnNameToConfigInterfaceMap = new HashMap<>();
  67         Map<String, Integer> vpnNameToOperInterfaceMap = new HashMap<>();
  68         if (detail == null) {
  69             showVpn();
  70             Set<String> vpnInstances = new HashSet<>();
  71             for (VpnInterface vpnInterface : vpnInterfaceConfigList) {
  72                 if (vpnInterface.getVpnInstanceNames() != null) {
  73                     for (VpnInstanceNames vpnInterfaceVpnInstance : vpnInterface.getVpnInstanceNames()) {
  74                         String vpnName = vpnInterfaceVpnInstance.getVpnName();
  75                         if (vpnName != null) {
  76                             vpnInstances.add(vpnName);
  77                         }
  78                     }
  79                 }
  80             }
  81             for (String routerId : vpnInstances) {
  82                 ifPresent = vpnNameToConfigInterfaceMap.get(routerId);
  83                 if (ifPresent == null) {
  84                     vpnNameToConfigInterfaceMap.put(routerId, 1);
  85                 } else {
  86                     vpnNameToConfigInterfaceMap.put(routerId,
  87                                       vpnNameToConfigInterfaceMap.get(routerId) + 1);
  88                 }
  89             }
  90             for (VpnInterfaceOpDataEntry vpnInterfaceOp : vpnInterfaceOpList) {
  91                 ifPresent = vpnNameToOperInterfaceMap.get(vpnInterfaceOp.getVpnInstanceName());
  92                 if (ifPresent == null) {
  93                     vpnNameToOperInterfaceMap.put(vpnInterfaceOp.getVpnInstanceName(), 1);
  94                 } else {
  95                     vpnNameToOperInterfaceMap.put(vpnInterfaceOp.getVpnInstanceName(),
  96                         vpnNameToOperInterfaceMap.get(vpnInterfaceOp.getVpnInstanceName()) + 1);
  97                 }
  98             }
  99             session.getConsole().println("-----------------------------------------------------------------------");
 100             session.getConsole().println(
 101                     String.format("         %s   %14s  %5s  %5s", "VpnInstanceName", "RD", "Config Count",
 102                             "Oper Count"));
 103             session.getConsole().println(
 104                     "\n-----------------------------------------------------------------------");
 105             for (VpnInstance vpnInstance : vpnInstanceList) {
 106                 configCount = 0;
 107                 operCount = 0;
 108                 Integer count = vpnNameToConfigInterfaceMap.get(vpnInstance.getVpnInstanceName());
 109                 if (count != null) {
 110                     configCount = vpnNameToConfigInterfaceMap.get(vpnInstance.getVpnInstanceName());
 111                     totalConfigCount = totalConfigCount + configCount;
 112                 }
 113                 count = vpnNameToOperInterfaceMap.get(vpnInstance.getVpnInstanceName());
 114                 if (count != null) {
 115                     operCount = vpnNameToOperInterfaceMap.get(vpnInstance.getVpnInstanceName());
 116                     totalOperCount = totalOperCount + operCount;
 117                 }
 118                 session.getConsole().println(
 119                         String.format("%-32s  %-10s  %-10s  %-10s", vpnInstance.getVpnInstanceName(),
 120                                 vpnInstance.getRouteDistinguisher(), configCount, operCount));
 121             }
 122             session.getConsole().println("-----------------------------------------------------------------------");
 123             session.getConsole().println(
 124                     String.format("Total Count:                    %19s    %8s", totalConfigCount, totalOperCount));
 125             session.getConsole().println(getshowVpnCLIHelp());
 126         } else {
 127             showVpn();
 128             session.getConsole().println("Present Config VpnInterfaces are:");
 129             for (VpnInterface vpnInterface : vpnInterfaceConfigList) {
 130                 if (VpnHelper.doesVpnInterfaceBelongToVpnInstance(detail, vpnInterface.getVpnInstanceNames())) {
 131                     session.getConsole().println(vpnInterface.getName());
 132                 }
 133             }
 134             session.getConsole().println("Present Oper VpnInterfaces are:");
 135             for (VpnInterfaceOpDataEntry vpnInterfaceOp : vpnInterfaceOpList) {
 136                 if (Objects.equals(vpnInterfaceOp.getVpnInstanceName(), detail)) {
 137                     session.getConsole().println(vpnInterfaceOp.getName());
 138                 }
 139             }
 140         }
 141         return null;
 142     }
 143
 144     private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
 145             InstanceIdentifier<T> path) {
 146         try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
 147             return tx.read(datastoreType, path).get();
 148         } catch (InterruptedException | ExecutionException e) {
 149             throw new RuntimeException(e);
 150         }
 151     }
 152
 153     private void showVpn() {
 154         InstanceIdentifier<VpnInstances> vpnsIdentifier = InstanceIdentifier.builder(VpnInstances.class).build();
 155         InstanceIdentifier<VpnInterfaces> vpnInterfacesIdentifier = InstanceIdentifier.builder(VpnInterfaces
 156                 .class).build();
 157         Optional<VpnInstances> optionalVpnInstances = read(LogicalDatastoreType.CONFIGURATION, vpnsIdentifier);
 158
 159         if (!optionalVpnInstances.isPresent()) {
 160             LOG.trace("No VPNInstances configured.");
 161             session.getConsole().println("No VPNInstances configured.");
 162         } else {
 163             vpnInstanceList = optionalVpnInstances.get().getVpnInstance();
 164         }
 165
 166         Optional<VpnInterfaces> optionalVpnInterfacesConfig =
 167                 read(LogicalDatastoreType.CONFIGURATION, vpnInterfacesIdentifier);
 168
 169         if (!optionalVpnInterfacesConfig.isPresent()) {
 170             LOG.trace("No Config VpnInterface is present");
 171             session.getConsole().println("No Config VpnInterface is present");
 172         } else {
 173             vpnInterfaceConfigList = optionalVpnInterfacesConfig.get().getVpnInterface();
 174         }
 175
 176
 177         InstanceIdentifier<VpnInterfaceOpData> id = InstanceIdentifier.create(VpnInterfaceOpData.class);
 178         Optional<VpnInterfaceOpData> optionalVpnInterfacesOper = read(LogicalDatastoreType.OPERATIONAL, id);
 179
 180         if (!optionalVpnInterfacesOper.isPresent()) {
 181             LOG.trace("No Oper VpnInterface is present");
 182             session.getConsole().println("No Oper VpnInterface is present");
 183         } else {
 184             vpnInterfaceOpList = optionalVpnInterfacesOper.get().getVpnInterfaceOpDataEntry();
 185         }
 186     }
 187
 188     private String getshowVpnCLIHelp() {
 189         StringBuilder help = new StringBuilder("\nUsage:");
 190         help.append("To display vpn-interfaces for a particular vpnInstance vpn-show --detail [<vpnInstanceName>]");
 191         return help.toString();
 192     }
 193 }