itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java

   1 /*
   2  * Copyright (c) 2016 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.genius.itm.impl;
   9
  10 import com.google.common.base.Preconditions;
  11 import java.math.BigInteger;
  12 import java.util.List;
  13 import java.util.concurrent.ExecutionException;
  14 import java.util.concurrent.Future;
  15 import java.util.regex.Matcher;
  16 import java.util.regex.Pattern;
  17
  18 import org.apache.felix.service.command.CommandSession;
  19
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  23 import org.opendaylight.genius.itm.api.IITMProvider;
  24 import org.opendaylight.genius.itm.cli.TepCommandHelper;
  25 import org.opendaylight.genius.itm.listeners.cache.DpnTepsInfoListener;
  26 import org.opendaylight.genius.itm.cli.TepException;
  27 import org.opendaylight.genius.itm.globals.ITMConstants;
  28 import org.opendaylight.genius.itm.listeners.InterfaceStateListener;
  29 import org.opendaylight.genius.itm.listeners.TransportZoneListener;
  30 import org.opendaylight.genius.itm.listeners.cache.StateTunnelListListener;
  31 import org.opendaylight.genius.itm.listeners.TunnelMonitorChangeListener;
  32 import org.opendaylight.genius.itm.listeners.TunnelMonitorIntervalListener;
  33 import org.opendaylight.genius.itm.listeners.VtepConfigSchemaListener;
  34 import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringIntervalListener;
  35 import org.opendaylight.genius.itm.listeners.cache.ItmMonitoringListener;
  36 import org.opendaylight.genius.itm.monitoring.ItmTunnelEventListener;
  37 import org.opendaylight.genius.itm.rpc.ItmManagerRpcService;
  38 import org.opendaylight.genius.itm.snd.ITMStatusMonitor;
  39 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.VtepConfigSchemas;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.vtep.config.schemas.VtepConfigSchema;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.vtep.config.schemas.VtepConfigSchemaBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInputBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInputBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
  53 import org.opendaylight.yangtools.yang.common.RpcResult;
  54 import org.slf4j.Logger;
  55 import org.slf4j.LoggerFactory;
  56
  57 import javax.annotation.PostConstruct;
  58 import javax.annotation.PreDestroy;
  59 import javax.inject.Inject;
  60 import javax.inject.Singleton;
  61
  62 @Singleton
  63 public class ItmProvider implements AutoCloseable, IITMProvider /*,ItmStateService */{
  64
  65     private static final Logger LOG = LoggerFactory.getLogger(ItmProvider.class);
  66     private ITMManager itmManager;
  67     private DataBroker dataBroker;
  68     private ItmManagerRpcService itmRpcService ;
  69     private IdManagerService idManager;
  70     private TepCommandHelper tepCommandHelper;
  71     private TransportZoneListener tzChangeListener;
  72     private TunnelMonitorChangeListener tnlToggleListener;
  73     private TunnelMonitorIntervalListener tnlIntervalListener;
  74     private VtepConfigSchemaListener vtepConfigSchemaListener;
  75     private InterfaceStateListener ifStateListener;
  76     private RpcProviderRegistry rpcProviderRegistry;
  77     private static final ITMStatusMonitor itmStatusMonitor = ITMStatusMonitor.getInstance();
  78     private ItmTunnelEventListener itmStateListener;
  79     private ItmMonitoringListener itmMonitoringListener;
  80     private ItmMonitoringIntervalListener itmMonitoringIntervalListener;
  81     static short flag = 0;
  82     private StateTunnelListListener tunnelStateListener ;
  83     private DpnTepsInfoListener dpnTepsInfoListener ;
  84
  85     @Inject
  86     public ItmProvider(DataBroker dataBroker,
  87                        DpnTepsInfoListener dpnTepsInfoListener,
  88                        IdManagerService idManagerService,
  89                        InterfaceStateListener interfaceStateListener,
  90                        ITMManager itmManager,
  91                        ItmManagerRpcService itmManagerRpcService,
  92                        ItmMonitoringListener itmMonitoringListener,
  93                        ItmMonitoringIntervalListener itmMonitoringIntervalListener,
  94                        ItmTunnelEventListener itmTunnelEventListener,
  95                        StateTunnelListListener stateTunnelListListener,
  96                        TepCommandHelper tepCommandHelper,
  97                        TunnelMonitorChangeListener tunnelMonitorChangeListener,
  98                        TunnelMonitorIntervalListener tunnelMonitorIntervalListener,
  99                        TransportZoneListener transportZoneListener,
 100                        VtepConfigSchemaListener vtepConfigSchemaListener) {
 101         LOG.info("ItmProvider Before register MBean");
 102         itmStatusMonitor.registerMbean();
 103         this.dataBroker = dataBroker;
 104         this.dpnTepsInfoListener = dpnTepsInfoListener;
 105         this.idManager = idManagerService;
 106         this.ifStateListener = interfaceStateListener;
 107         this.itmManager = itmManager;
 108         this.itmRpcService = itmManagerRpcService;
 109         this.itmMonitoringListener = itmMonitoringListener;
 110         this.itmMonitoringIntervalListener = itmMonitoringIntervalListener;
 111         this.itmStateListener = itmTunnelEventListener;
 112         this.tunnelStateListener = stateTunnelListListener;
 113         this.tepCommandHelper = tepCommandHelper;
 114         this.tnlToggleListener = tunnelMonitorChangeListener;
 115         this.tnlIntervalListener = tunnelMonitorIntervalListener;
 116         this.tzChangeListener = transportZoneListener;
 117         this.vtepConfigSchemaListener = vtepConfigSchemaListener;
 118     }
 119
 120     @PostConstruct
 121     public void start() throws Exception {
 122         createIdPool();
 123         LOG.info("ItmProvider Started");
 124     }
 125
 126     @Override
 127     @PreDestroy
 128     public void close() throws Exception {
 129         if (itmManager != null) {
 130             itmManager.close();
 131         }
 132         if (tzChangeListener != null) {
 133             tzChangeListener.close();
 134         }
 135         if (tnlIntervalListener != null) {
 136             tnlIntervalListener.close();
 137         }
 138         if(tnlToggleListener!= null){
 139             tnlToggleListener.close();
 140         }
 141         if(tunnelStateListener!= null){
 142             tunnelStateListener.close();
 143         }
 144         if(dpnTepsInfoListener!= null){
 145             dpnTepsInfoListener.close();
 146         }
 147         LOG.info("ItmProvider Closed");
 148     }
 149
 150     private void createIdPool() {
 151         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
 152                 .setPoolName(ITMConstants.ITM_IDPOOL_NAME)
 153                 .setLow(ITMConstants.ITM_IDPOOL_START)
 154                 .setHigh(new BigInteger(ITMConstants.ITM_IDPOOL_SIZE).longValue())
 155                 .build();
 156         try {
 157             Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
 158             if ((result != null) && (result.get().isSuccessful())) {
 159                 LOG.debug("Created IdPool for ITM Service");
 160             }
 161         } catch (InterruptedException | ExecutionException e) {
 162             LOG.error("Failed to create idPool for ITM Service",e);
 163         }
 164     }
 165
 166     @Override
 167     public DataBroker getDataBroker() {
 168         return dataBroker;
 169     }
 170
 171     public void addExternalEndpoint(Class<? extends TunnelTypeBase> tunnelType, IpAddress dcgwIP) {
 172         AddExternalTunnelEndpointInput addExternalTunnelEndpointInput =
 173                 new AddExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType)
 174                         .setDestinationIp(dcgwIP).build();
 175         itmRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
 176     }
 177
 178     public void remExternalEndpoint(Class<? extends TunnelTypeBase> tunnelType, IpAddress dcgwIP) {
 179         RemoveExternalTunnelEndpointInput removeExternalTunnelEndpointInput =
 180                 new RemoveExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType)
 181                         .setDestinationIp(dcgwIP).build();
 182         itmRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput);
 183     }
 184     @Override
 185     public void createLocalCache(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
 186                                  String gatewayIp, String transportZone, CommandSession session) {
 187         if (tepCommandHelper != null) {
 188             try {
 189                 tepCommandHelper.createLocalCache(dpnId, portName, vlanId, ipAddress, subnetMask, gatewayIp, transportZone, session);
 190             } catch (TepException e) {
 191                 LOG.error(e.getMessage());
 192             }
 193         } else {
 194             LOG.trace("tepCommandHelper doesnt exist");
 195         }
 196     }
 197
 198     @Override
 199     public void commitTeps() {
 200         try {
 201             tepCommandHelper.deleteOnCommit();
 202             tepCommandHelper.buildTeps();
 203         } catch (Exception e) {
 204             LOG.debug("unable to configure teps" + e.toString());
 205         }
 206     }
 207
 208     @Override
 209     public void showTeps(CommandSession session) {
 210         try {
 211             tepCommandHelper.showTeps(itmManager.getTunnelMonitorEnabledFromConfigDS(), ItmUtils.determineMonitorInterval(this.dataBroker), session);
 212         } catch (TepException e) {
 213             LOG.error(e.getMessage());
 214         }
 215     }
 216
 217     public void showState(List<StateTunnelList> tunnels,CommandSession session) {
 218         if (tunnels != null) {
 219             try {
 220                 tepCommandHelper.showState(tunnels, itmManager.getTunnelMonitorEnabledFromConfigDS(), session);
 221             }catch(TepException e) {
 222                 LOG.error(e.getMessage());
 223             }
 224         }else
 225             LOG.debug("No tunnels available");
 226     }
 227
 228     @Override
 229     public void showCache( String cacheName) {
 230         tepCommandHelper.showCache(cacheName);
 231     }
 232
 233     public void deleteVtep(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
 234                            String gatewayIp, String transportZone, CommandSession session) {
 235         try {
 236             tepCommandHelper.deleteVtep(dpnId,  portName, vlanId, ipAddress, subnetMask, gatewayIp, transportZone, session);
 237         } catch (Exception e) {
 238             LOG.error(e.getMessage());
 239         }
 240     }
 241
 242     @Override
 243     public void configureTunnelType(String transportZone, String tunnelType) {
 244         LOG .debug("ItmProvider: configureTunnelType {} for transportZone {}", tunnelType, transportZone);
 245         tepCommandHelper.configureTunnelType(transportZone,tunnelType);
 246     }
 247
 248     @Override
 249     public void addVtepConfigSchema(VtepConfigSchema vtepConfigSchema) {
 250         VtepConfigSchema validatedSchema = ItmUtils.validateForAddVtepConfigSchema(vtepConfigSchema,
 251                 getAllVtepConfigSchemas());
 252
 253         String schemaName = validatedSchema.getSchemaName();
 254         VtepConfigSchema existingSchema = getVtepConfigSchema(schemaName);
 255         if (existingSchema != null) {
 256             Preconditions.checkArgument(false, String.format("VtepConfigSchema [%s] already exists!", schemaName));
 257         }
 258         MDSALUtil.syncWrite(this.dataBroker, LogicalDatastoreType.CONFIGURATION,
 259                 ItmUtils.getVtepConfigSchemaIdentifier(schemaName), validatedSchema);
 260         LOG.debug("Vtep config schema {} added to config DS", schemaName);
 261     }
 262
 263     @Override
 264     public VtepConfigSchema getVtepConfigSchema(String schemaName) {
 265         return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, ItmUtils.getVtepConfigSchemaIdentifier(schemaName),
 266                 this.dataBroker).orNull();
 267     }
 268
 269     @Override
 270     public List<VtepConfigSchema> getAllVtepConfigSchemas() {
 271         return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, ItmUtils.getVtepConfigSchemasIdentifier(),
 272                 this.dataBroker).transform(VtepConfigSchemas::getVtepConfigSchema).orNull();
 273     }
 274
 275     @Override
 276     public void updateVtepSchema(String schemaName, List<BigInteger> lstDpnsForAdd, List<BigInteger> lstDpnsForDelete) {
 277         LOG.trace("Updating VTEP schema {} by adding DPN's {} and deleting DPN's {}.", schemaName, lstDpnsForAdd,
 278                 lstDpnsForDelete);
 279
 280         VtepConfigSchema schema = ItmUtils.validateForUpdateVtepSchema(schemaName, lstDpnsForAdd, lstDpnsForDelete,
 281                 this);
 282         VtepConfigSchemaBuilder builder = new VtepConfigSchemaBuilder(schema);
 283        /* if (ItmUtils.getDpnIdList(schema.getDpnIds()).isEmpty()) {
 284             builder.setDpnIds(schema.getDpnIds());
 285         } else {*/
 286             if (lstDpnsForAdd != null && !lstDpnsForAdd.isEmpty()) {
 287                 List<BigInteger> originalDpnList = ItmUtils.getDpnIdList(schema.getDpnIds()) ;
 288                 originalDpnList.addAll(lstDpnsForAdd) ;
 289                 builder.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(originalDpnList));
 290             }
 291             if (lstDpnsForDelete != null && !lstDpnsForDelete.isEmpty()) {
 292                 List<BigInteger> originalDpnList = ItmUtils.getDpnIdList(schema.getDpnIds()) ;
 293                 originalDpnList.removeAll(lstDpnsForDelete) ;
 294                 builder.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(originalDpnList)) ;
 295                 // schema.setDpnIds(ItmUtils.getDpnIdsListFromBigInt(ItmUtils.getDpnIdList(schema.getDpnIds()).removeAll(lstDpnsForAdd)));
 296             }
 297        // }
 298         schema = builder.build();
 299         MDSALUtil.syncWrite(this.dataBroker, LogicalDatastoreType.CONFIGURATION,
 300                 ItmUtils.getVtepConfigSchemaIdentifier(schemaName), schema);
 301         LOG.debug("Vtep config schema {} updated to config DS with DPN's {}", schemaName, ItmUtils.getDpnIdList(schema.getDpnIds()));
 302     }
 303
 304     @Override
 305     public void deleteAllVtepSchemas() {
 306         List<VtepConfigSchema> lstSchemas = getAllVtepConfigSchemas();
 307         if (lstSchemas != null && !lstSchemas.isEmpty()) {
 308             for (VtepConfigSchema schema : lstSchemas) {
 309                 MDSALUtil.syncDelete(this.dataBroker, LogicalDatastoreType.CONFIGURATION,
 310                         ItmUtils.getVtepConfigSchemaIdentifier(schema.getSchemaName()));
 311             }
 312         }
 313         LOG.debug("Deleted all Vtep schemas from config DS");
 314     }
 315
 316     public void configureTunnelMonitorParams(boolean monitorEnabled, String monitorProtocol) {
 317         tepCommandHelper.configureTunnelMonitorParams(monitorEnabled, monitorProtocol);
 318     }
 319
 320     public void configureTunnelMonitorInterval(int interval) {
 321         tepCommandHelper.configureTunnelMonitorInterval(interval);
 322     }
 323
 324     public boolean validateIP (final String ip){
 325         if (ip == null || ip.equals("")) {
 326             return false;
 327         }
 328         final String PATTERN =
 329                 "^(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";
 330         Pattern pattern = Pattern.compile(PATTERN);
 331         Matcher matcher = pattern.matcher(ip);
 332         return matcher.matches();
 333     }
 334 }