networkutils/networkutils/src/main/java/org/opendaylight/genius/networkutils/impl/RDUtilsImpl.java

   1 /*
   2  * Copyright © 2018 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.networkutils.impl;
   9
  10 import com.google.common.annotations.VisibleForTesting;
  11 import com.google.common.base.Optional;
  12 import java.util.concurrent.ExecutionException;
  13 import java.util.concurrent.Future;
  14 import javax.inject.Inject;
  15 import javax.inject.Singleton;
  16
  17 import org.apache.aries.blueprint.annotation.service.Reference;
  18 import org.apache.aries.blueprint.annotation.service.Service;
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  21 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  22 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  23 import org.opendaylight.genius.mdsalutil.NwConstants;
  24 import org.opendaylight.genius.networkutils.RDUtils;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInput;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolOutput;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.networkutils.config.rev181129.NetworkConfig;
  42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  43 import org.opendaylight.yangtools.yang.common.RpcResult;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 @Singleton
  48 @Service(classes = RDUtils.class)
  49 public class RDUtilsImpl implements RDUtils {
  50
  51     private static final Logger LOG = LoggerFactory.getLogger(RDUtilsImpl.class);
  52
  53     private final IdManagerService idManagerService;
  54     private final DataBroker dataBroker;
  55     private final NetworkConfig networkConfig;
  56
  57     @Inject
  58     public RDUtilsImpl(NetworkConfig networkConfig, IdManagerService idManagerService,
  59                        @Reference DataBroker dataBroker) throws ReadFailedException {
  60         this.idManagerService = idManagerService;
  61         this.dataBroker = dataBroker;
  62         this.networkConfig = networkConfig;
  63         validateAndCreateRDPool();
  64     }
  65
  66     /*
  67      * if the base RD is 100:1 and generated idValue is 100, this fn returns 100:101
  68      * if the base RD is 200:2000 and generated RD value is 64000, this fn should return 201:2465
  69      *
  70      *   if RD is x:y
  71      *   y can go till 65535(RD_MAX_VALUE_FIELD) and then x is incremented with y reset to 0
  72      */
  73
  74     public String convertIdValuetoRD(long idValue) {
  75         String configuredRDStartValue = networkConfig.getOpendaylightRdStartValue();
  76         String[] configureRDSplit = NwConstants.RD_DEFAULT_LOW_VALUE.split(":");
  77         if (configuredRDStartValue != null) {
  78             configureRDSplit = configuredRDStartValue.split(":");
  79         }
  80         long baseAsNum = Long.parseLong(configureRDSplit[0]);
  81         long baseValue = Long.parseLong(configureRDSplit[1]);
  82         baseAsNum = baseAsNum + ((baseValue + idValue) / NwConstants.RD_MAX_VALUE_FIELD) ;
  83         baseValue = (baseValue + idValue) % NwConstants.RD_MAX_VALUE_FIELD ;
  84
  85         return String.valueOf(baseAsNum) + ":" + String.valueOf(baseValue);
  86     }
  87
  88     @Override
  89     public String getRD(String rdKey) throws ExecutionException, InterruptedException {
  90         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(NwConstants.ODL_RD_POOL_NAME)
  91                 .setIdKey(rdKey).build();
  92         Future<RpcResult<AllocateIdOutput>> result = idManagerService.allocateId(getIdInput);
  93         RpcResult<AllocateIdOutput> rpcResult = result.get();
  94         if (rpcResult.isSuccessful()) {
  95             String rd = convertIdValuetoRD(rpcResult.getResult().getIdValue());
  96             return rd;
  97         }
  98         return null;
  99     }
 100
 101     @Override
 102     public void releaseRD(String rdKey) throws ExecutionException, InterruptedException {
 103         ReleaseIdInput releaseIdInput = new ReleaseIdInputBuilder().setPoolName(NwConstants.ODL_RD_POOL_NAME)
 104                 .setIdKey(rdKey).build();
 105         RpcResult<ReleaseIdOutput> rpcResult = idManagerService.releaseId(releaseIdInput).get();
 106         if (!rpcResult.isSuccessful()) {
 107             LOG.warn("releaseRD : Unable to release ID {} from OpenDaylight RD pool. Error {}",
 108                     rdKey, rpcResult.getErrors());
 109         }
 110     }
 111
 112     public Optional<IdPool> getRDPool() throws ReadFailedException {
 113         return SingleTransactionDataBroker.syncReadOptional(dataBroker,
 114                 LogicalDatastoreType.CONFIGURATION, buildIdPoolInstanceIdentifier(NwConstants.ODL_RD_POOL_NAME));
 115     }
 116
 117     private void validateAndCreateRDPool() throws ReadFailedException {
 118         long lowLimit = 0L;
 119         long highLimit = networkConfig.getOpendaylightRdCount();
 120         if (highLimit == 0L) {
 121             highLimit = NwConstants.RD_DEFAULT_COUNT;
 122         }
 123         Optional<IdPool> existingIdPool = SingleTransactionDataBroker.syncReadOptional(dataBroker,
 124                 LogicalDatastoreType.CONFIGURATION,
 125                 buildIdPoolInstanceIdentifier(NwConstants.ODL_RD_POOL_NAME));
 126         if (existingIdPool.isPresent()) {
 127             IdPool odlRDPool = existingIdPool.get();
 128             long currentStartLimit = odlRDPool.getAvailableIdsHolder().getStart();
 129             long currentEndLimit = odlRDPool.getAvailableIdsHolder().getEnd();
 130
 131             if (lowLimit == currentStartLimit && highLimit == currentEndLimit) {
 132                 LOG.debug("validateAndCreateRDPool : OpenDaylight RD pool already exists "
 133                         + "with configured Range");
 134             } else {
 135                 if (odlRDPool.getIdEntries() != null && odlRDPool.getIdEntries().size() != 0) {
 136                     LOG.warn("validateAndCreateRDPool : Some Allocation already exists with old Range. "
 137                             + "Cannot modify existing limit of OpenDaylight RD pool");
 138                 } else {
 139                     LOG.debug("validateAndCreateRDPool : No RDs allocated from OpenDaylight RD pool "
 140                             + "Delete and re-create pool with new configured Range {}-{}",lowLimit, highLimit);
 141                     deleteOpenDaylightRDPool();
 142                     createOpenDaylightRDPool(lowLimit, highLimit);
 143                 }
 144             }
 145         } else {
 146             createOpenDaylightRDPool(lowLimit, highLimit);
 147         }
 148     }
 149
 150     private void createOpenDaylightRDPool(long lowLimit, long highLimit) {
 151         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
 152                 .setPoolName(NwConstants.ODL_RD_POOL_NAME).setLow(lowLimit).setHigh(highLimit).build();
 153         try {
 154             Future<RpcResult<CreateIdPoolOutput>> result = idManagerService.createIdPool(createPool);
 155             if (result != null && result.get().isSuccessful()) {
 156                 LOG.debug("createOpenDaylightRDPool : Created OpenDaylight RD pool {} "
 157                         + "with range {}-{}", NwConstants.ODL_RD_POOL_NAME, lowLimit, highLimit);
 158             } else {
 159                 LOG.error("createOpenDaylightRDPool : Failed to create OpenDaylight RD pool {} "
 160                         + "with range {}-{}", NwConstants.ODL_RD_POOL_NAME, lowLimit, highLimit);
 161             }
 162         } catch (InterruptedException | ExecutionException e) {
 163             LOG.error("createOpenDaylightRDPool : Failed to create OpenDaylight RD pool {} "
 164                     + "with range {}-{}", NwConstants.ODL_RD_POOL_NAME, lowLimit, highLimit);
 165         }
 166     }
 167
 168     private void deleteOpenDaylightRDPool() {
 169
 170         DeleteIdPoolInput deletePool = new DeleteIdPoolInputBuilder()
 171                 .setPoolName(NwConstants.ODL_RD_POOL_NAME).build();
 172         Future<RpcResult<DeleteIdPoolOutput>> result = idManagerService.deleteIdPool(deletePool);
 173         try {
 174             if (result != null && result.get().isSuccessful()) {
 175                 LOG.debug("deleteOpenDaylightRDPool : Deleted OpenDaylight RD pool {} successfully",
 176                         NwConstants.ODL_RD_POOL_NAME);
 177             } else {
 178                 LOG.error("deleteOpenDaylightRDPool : Failed to delete OpenDaylight RD pool {} ",
 179                         NwConstants.ODL_RD_POOL_NAME);
 180             }
 181         } catch (InterruptedException | ExecutionException e) {
 182             LOG.error("deleteOpenDaylightRDPool : Failed to delete OpenDaylight RD range pool {} ",
 183                     NwConstants.ODL_RD_POOL_NAME, e);
 184         }
 185     }
 186
 187     @VisibleForTesting
 188     InstanceIdentifier<IdPool> buildIdPoolInstanceIdentifier(String poolName) {
 189         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idPoolBuilder =
 190                 InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 191         return idPoolBuilder.build();
 192     }
 193 }