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         return true;
  91     }
  92
  93     /**
  94     * Delete a Neutron Port status entry from the operational data store.
  95     * @param uuid The uuid of the Neutron port
  96     * @param dataBroker DataBroker instance
  97     * @return true if transaction submitted successfully
  98     */
  99     public static boolean deletePortStatus(String uuid, DataBroker dataBroker) {
 100         Uuid uuidObj = new Uuid(uuid);
 101
 102         InstanceIdentifier iid = InstanceIdentifier.create(Neutron.class).child(Ports.class).child(
 103                 Port.class, new PortKey(uuidObj));
 104         SingleTransactionDataBroker tx = new SingleTransactionDataBroker(dataBroker);
 105         try {
 106             tx.syncDelete(LogicalDatastoreType.OPERATIONAL, iid);
 107         } catch (TransactionCommitFailedException e) {
 108             LOG.error("deletePortStatus: failed neutron port status delete", e);
 109             return false;
 110         }
 111
 112         return true;
 113     }
 114
 115     public static boolean isPortVnicTypeNormal(Port port) {
 116         PortBindingExtension portBinding = port.getAugmentation(PortBindingExtension.class);
 117         if (portBinding == null || portBinding.getVnicType() == null) {
 118             // By default, VNIC_TYPE is NORMAL
 119             return true;
 120         }
 121         String vnicType = portBinding.getVnicType().trim().toLowerCase(Locale.getDefault());
 122         return vnicType.equals(VNIC_TYPE_NORMAL);
 123     }
 124
 125     public static <T extends NetworkTypeBase> String getSegmentationIdFromNeutronNetwork(Network network,
 126             Class<T> networkType) {
 127         String segmentationId = null;
 128         NetworkProviderExtension providerExtension = network.getAugmentation(NetworkProviderExtension.class);
 129         if (providerExtension != null) {
 130             segmentationId = providerExtension.getSegmentationId();
 131             if (segmentationId == null) {
 132                 List<Segments> providerSegments = providerExtension.getSegments();
 133                 if (providerSegments != null && providerSegments.size() > 0) {
 134                     for (Segments providerSegment: providerSegments) {
 135                         if (isNetworkSegmentType(providerSegment, networkType)) {
 136                             segmentationId = providerSegment.getSegmentationId();
 137                             break;
 138                         }
 139                     }
 140                 }
 141             }
 142         }
 143         return segmentationId;
 144     }
 145
 146     static <T extends NetworkTypeBase> boolean isNetworkSegmentType(Segments providerSegment,
 147             Class<T> expectedNetworkType) {
 148         Class<? extends NetworkTypeBase> networkType = providerSegment.getNetworkType();
 149         return networkType != null && networkType.isAssignableFrom(expectedNetworkType);
 150     }
 151
 152     public static <T extends NetworkTypeBase> boolean isNetworkSegmentType(Network network, Long index,
 153                                                                            Class<T> expectedNetworkType) {
 154         Class<? extends NetworkTypeBase> segmentType = null;
 155         NetworkProviderExtension providerExtension = network.getAugmentation(NetworkProviderExtension.class);
 156         if (providerExtension != null) {
 157             List<Segments> providerSegments = providerExtension.getSegments();
 158             if (providerSegments != null && providerSegments.size() > 0) {
 159                 for (Segments providerSegment : providerSegments) {
 160                     if (Objects.equals(providerSegment.getSegmentationIndex(), index)) {
 161                         segmentType = providerSegment.getNetworkType();
 162                         break;
 163                     }
 164                 }
 165             }
 166         }
 167         return segmentType != null && segmentType.isAssignableFrom(expectedNetworkType);
 168     }
 169
 170     public static Long getNumberSegmentsFromNeutronNetwork(Network network) {
 171         NetworkProviderExtension providerExtension = network.getAugmentation(NetworkProviderExtension.class);
 172         Integer numSegs = 0;
 173         if (providerExtension != null) {
 174             List<Segments> providerSegments = providerExtension.getSegments();
 175             if (providerSegments != null) {
 176                 numSegs = providerSegments.size();
 177             }
 178         }
 179         return Long.valueOf(numSegs);
 180     }
 181
 182     public static String getSegmentationIdFromNeutronNetworkSegment(Network network, Long index) {
 183         String segmentationId = null;
 184         NetworkProviderExtension providerExtension = network.getAugmentation(NetworkProviderExtension.class);
 185         if (providerExtension != null) {
 186             List<Segments> providerSegments = providerExtension.getSegments();
 187             if (providerSegments != null && providerSegments.size() > 0) {
 188                 for (Segments providerSegment : providerSegments) {
 189                     if (Objects.equals(providerSegment.getSegmentationIndex(), index)) {
 190                         segmentationId = providerSegment.getSegmentationId();
 191                         break;
 192                     }
 193                 }
 194             }
 195         }
 196         return segmentationId;
 197     }
 198
 199     public static boolean isUuid(String possibleUuid) {
 200         Preconditions.checkNotNull(possibleUuid, "possibleUuid == null");
 201
 202         if (uuidPattern == null) {
 203             // Thread safe because it really doesn't matter even if we were to do this initialization more than once
 204             if (Uuid.PATTERN_CONSTANTS.size() != 1) {
 205                 throw new IllegalStateException("Uuid.PATTERN_CONSTANTS.size() != 1");
 206             }
 207             uuidPattern = Pattern.compile(Uuid.PATTERN_CONSTANTS.get(0));
 208         }
 209
 210         if (uuidPattern.matcher(possibleUuid).matches()) {
 211             return Boolean.TRUE;
 212         } else {
 213             return Boolean.FALSE;
 214         }
 215     }
 216 }