appc-dg/appc-dg-shared/appc-dg-common/src/main/java/org/openecomp/appc/dg/common/impl/AbstractResolver.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * APPC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * Copyright (C) 2017 Amdocs
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  */
  22
  23 package org.openecomp.appc.dg.common.impl;
  24
  25 import org.openecomp.appc.rankingframework.RankedAttributesResolver;
  26 import com.att.eelf.configuration.EELFLogger;
  27 import com.att.eelf.configuration.EELFManager;
  28
  29 import java.util.concurrent.locks.ReentrantLock;
  30
  31 abstract class AbstractResolver {
  32
  33     private static final EELFLogger logger = EELFManager.getInstance().getLogger(AbstractResolver.class);
  34
  35     private long interval;
  36
  37     private volatile long lastUpdate = 0l;
  38     private volatile boolean isUpdateInProgress = false;
  39     private volatile RankedAttributesResolver<FlowKey> dgResolver;
  40
  41     private final ReentrantLock INIT_LOCK = new ReentrantLock();
  42
  43     AbstractResolver(int interval) {
  44         this.interval = interval * 1000;
  45     }
  46
  47     private RankedAttributesResolver<FlowKey> createResolver(String resolverType) {
  48         AbstractResolverDataReader reader = ResolverDataReaderFactory.createResolverDataReader(resolverType);
  49         return reader.read();
  50     }
  51
  52     private boolean isExpired() {
  53         return (System.currentTimeMillis() - lastUpdate) > interval;
  54     }
  55
  56     protected RankedAttributesResolver<FlowKey> resolver(String resolverType) {
  57
  58         /*
  59          * In general case, the method implementation is non-blocking. The first
  60          * thread that identifies data expiration will be used to refresh it. In
  61          * meanwhile, any other thread will get the old instance without waiting
  62          * for the updated one. The only exception is the very first time when
  63          * previous instance doesn't exist - in such a cases all the threads
  64          * will be waiting on INIT_LOCK while one of them initializes the
  65          * resolver instance. NOTE: The initialization is intentionally
  66          * implemented in lazy manner to make sure the bundle is initialized
  67          * properly on startup regardless whether or not the data is correct.
  68          * Afterwards, the resolver may be instantiated as many times as needed.
  69          */
  70
  71         try {
  72
  73             if (dgResolver == null) {
  74                 INIT_LOCK.lock();
  75                 if (dgResolver != null) {
  76                     INIT_LOCK.unlock();
  77                 }
  78             }
  79
  80             if (!isUpdateInProgress && isExpired()) {
  81
  82                 boolean doUpgrade = false;
  83
  84                 synchronized (this) {
  85                     if (!isUpdateInProgress) {
  86                         isUpdateInProgress = true;
  87                         doUpgrade = true;
  88                     }
  89                 }
  90
  91                 if (doUpgrade) {
  92
  93                     logger.info("DG resolver configuration data has expired - initiating refresh");
  94
  95                     try {
  96                         RankedAttributesResolver<FlowKey> temp = createResolver(resolverType);
  97                         dgResolver = temp;
  98                         lastUpdate = System.currentTimeMillis();
  99
 100                         logger.info("DG resolver configuration data has been refreshed successfully");
 101                     } finally {
 102                         isUpdateInProgress = false;
 103                     }
 104                 }
 105             }
 106         } finally {
 107             if (INIT_LOCK.isHeldByCurrentThread()) {
 108                 INIT_LOCK.unlock();
 109             }
 110         }
 111
 112         return dgResolver;
 113     }
 114     protected abstract FlowKey resolve(final String...args);
 115 }