neutronvpn/api/src/main/java/org/opendaylight/netvirt/neutronvpn/api/utils/NeutronUtils.java

   1 /*
   2  * Copyright (c) 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
   9 package org.opendaylight.netvirt.neutronvpn.api.utils;
  10
  11 import com.google.common.base.Preconditions;
  12 import java.util.List;
  13 import java.util.Locale;
  14 import java.util.Objects;
  15 import java.util.regex.Pattern;
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  18 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  19 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  20 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeBase;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.NetworkProviderExtension;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.neutron.networks.network.Segments;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  31 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 public final class NeutronUtils {
  36     private static final Logger LOG = LoggerFactory.getLogger(NeutronUtils.class);
  37
  38     public static final String VNIC_TYPE_NORMAL = "normal";
  39     public static final String PORT_STATUS_ACTIVE = "ACTIVE";
  40     public static final String PORT_STATUS_BUILD = "BUILD";
  41     public static final String PORT_STATUS_DOWN = "DOWN";
  42     public static final String PORT_STATUS_ERROR = "ERROR";
  43     public static final String PORT_STATUS_NOTAPPLICABLE = "N/A";
  44     private static volatile Pattern uuidPattern;
  45
  46     private NeutronUtils() { }
  47
  48     /**
  49      * Create a Neutron Port status entry in the operational data store.
  50      * @param uuid The uuid of the Neutron port
  51      * @param portStatus value to set the status (see constants above)
  52      * @param dataBroker DataBroker instance
  53      * @return true if transaction submitted successfully
  54      */
  55     public static boolean createPortStatus(String uuid, String portStatus, DataBroker dataBroker) {
  56         return writePortStatus(uuid, portStatus, dataBroker, true);
  57     }
  58
  59     /**
  60      * Update a Neutron Port status entry in the operational data store.
  61      * @param uuid The uuid of the Neutron port
  62      * @param portStatus value to set the status (see constants above)
  63      * @param dataBroker DataBroker instance
  64      * @return true if transaction submitted successfully
  65      */
  66     public static boolean updatePortStatus(String uuid, String portStatus, DataBroker dataBroker) {
  67         return writePortStatus(uuid, portStatus, dataBroker, false);
  68     }
  69
  70     private static boolean writePortStatus(String uuid, String portStatus, DataBroker dataBroker, boolean create) {
  71         Uuid uuidObj = new Uuid(uuid);
  72         PortBuilder portBuilder = new PortBuilder();
  73         portBuilder.setUuid(uuidObj);
  74         portBuilder.setStatus(portStatus);
  75
  76         InstanceIdentifier iid = InstanceIdentifier.create(Neutron.class).child(Ports.class).child(
  77                                                                             Port.class, new PortKey(uuidObj));
  78         SingleTransactionDataBroker tx = new SingleTransactionDataBroker(dataBroker);
  79         try {
  80             if (create) {
  81                 tx.syncWrite(LogicalDatastoreType.OPERATIONAL, iid, portBuilder.build());
  82             } else {
  83                 tx.syncUpdate(LogicalDatastoreType.OPERATIONAL, iid, portBuilder.build());
  84             }
  85         } catch (TransactionCommitFailedException e) {
  86             LOG.error("writePortStatus: failed neutron port status write. isCreate: {}", create, e);
  87             return false;
  88         }
  89
  90         LOG.debug("writePortStatus: operational port status for {} set to {}", uuid, portStatus);
  91
  92         return true;
  93     }
  94
  95     /**
  96     * Delete a Neutron Port status entry from the operational data store.
  97     * @param uuid The uuid of the Neutron port
  98     * @param dataBroker DataBroker instance
  99     * @return true if transaction submitted successfully
 100     */
 101     public static boolean deletePortStatus(String uuid, DataBroker dataBroker) {
 102         Uuid uuidObj = new Uuid(uuid);
 103
 104         InstanceIdentifier iid = InstanceIdentifier.create(Neutron.class).child(Ports.class).child(
 105                 Port.class, new PortKey(uuidObj));
 106         SingleTransactionDataBroker tx = new SingleTransactionDataBroker(dataBroker);
 107         try {
 108             tx.syncDelete(LogicalDatastoreType.OPERATIONAL, iid);
 109         } catch (TransactionCommitFailedException e) {
 110             LOG.error("deletePortStatus: failed neutron port status delete", e);
 111             return false;
 112         }
 113
 114         return true;
 115     }
 116
 117     public static boolean isPortVnicTypeNormal(Port port) {
 118         PortBindingExtension portBinding = port.augmentation(PortBindingExtension.class);
 119         if (portBinding == null || portBinding.getVnicType() == null) {
 120             // By default, VNIC_TYPE is NORMAL
 121             return true;
 122         }
 123         String vnicType = portBinding.getVnicType().trim().toLowerCase(Locale.getDefault());
 124         return vnicType.equals(VNIC_TYPE_NORMAL);
 125     }
 126
 127     public static <T extends NetworkTypeBase> String getSegmentationIdFromNeutronNetwork(Network network,
 128             Class<T> networkType) {
 129         String segmentationId = null;
 130         NetworkProviderExtension providerExtension = network.augmentation(NetworkProviderExtension.class);
 131         if (providerExtension != null) {
 132             segmentationId = providerExtension.getSegmentationId();
 133             if (segmentationId == null) {
 134                 List<Segments> providerSegments = providerExtension.getSegments();
 135                 if (providerSegments != null && providerSegments.size() > 0) {
 136                     for (Segments providerSegment: providerSegments) {
 137                         if (isNetworkSegmentType(providerSegment, networkType)) {
 138                             segmentationId = providerSegment.getSegmentationId();
 139                             break;
 140                         }
 141                     }
 142                 }
 143             }
 144         }
 145         return segmentationId;
 146     }
 147
 148     static <T extends NetworkTypeBase> boolean isNetworkSegmentType(Segments providerSegment,
 149             Class<T> expectedNetworkType) {
 150         Class<? extends NetworkTypeBase> networkType = providerSegment.getNetworkType();
 151         return networkType != null && networkType.isAssignableFrom(expectedNetworkType);
 152     }
 153
 154     public static <T extends NetworkTypeBase> boolean isNetworkSegmentType(Network network, Long index,
 155                                                                            Class<T> expectedNetworkType) {
 156         Class<? extends NetworkTypeBase> segmentType = null;
 157         NetworkProviderExtension providerExtension = network.augmentation(NetworkProviderExtension.class);
 158         if (providerExtension != null) {
 159             List<Segments> providerSegments = providerExtension.getSegments();
 160             if (providerSegments != null && providerSegments.size() > 0) {
 161                 for (Segments providerSegment : providerSegments) {
 162                     if (Objects.equals(providerSegment.getSegmentationIndex(), index)) {
 163                         segmentType = providerSegment.getNetworkType();
 164                         break;
 165                     }
 166                 }
 167             }
 168         }
 169         return segmentType != null && segmentType.isAssignableFrom(expectedNetworkType);
 170     }
 171
 172     public static Long getNumberSegmentsFromNeutronNetwork(Network network) {
 173         NetworkProviderExtension providerExtension = network.augmentation(NetworkProviderExtension.class);
 174         Integer numSegs = 0;
 175         if (providerExtension != null) {
 176             List<Segments> providerSegments = providerExtension.getSegments();
 177             if (providerSegments != null) {
 178                 numSegs = providerSegments.size();
 179             }
 180         }
 181         return Long.valueOf(numSegs);
 182     }
 183
 184     public static String getSegmentationIdFromNeutronNetworkSegment(Network network, Long index) {
 185         String segmentationId = null;
 186         NetworkProviderExtension providerExtension = network.augmentation(NetworkProviderExtension.class);
 187         if (providerExtension != null) {
 188             List<Segments> providerSegments = providerExtension.getSegments();
 189             if (providerSegments != null && providerSegments.size() > 0) {
 190                 for (Segments providerSegment : providerSegments) {
 191                     if (Objects.equals(providerSegment.getSegmentationIndex(), index)) {
 192                         segmentationId = providerSegment.getSegmentationId();
 193                         break;
 194                     }
 195                 }
 196             }
 197         }
 198         return segmentationId;
 199     }
 200
 201     public static boolean isUuid(String possibleUuid) {
 202         Preconditions.checkNotNull(possibleUuid, "possibleUuid == null");
 203
 204         if (uuidPattern == null) {
 205             // Thread safe because it really doesn't matter even if we were to do this initialization more than once
 206             if (Uuid.PATTERN_CONSTANTS.size() != 1) {
 207                 throw new IllegalStateException("Uuid.PATTERN_CONSTANTS.size() != 1");
 208             }
 209             uuidPattern = Pattern.compile(Uuid.PATTERN_CONSTANTS.get(0));
 210         }
 211
 212         if (uuidPattern.matcher(possibleUuid).matches()) {
 213             return Boolean.TRUE;
 214         } else {
 215             return Boolean.FALSE;
 216         }
 217     }
 218 }