231 lines
8.3 KiB
Java
231 lines
8.3 KiB
Java
/**
|
|
*
|
|
*/
|
|
package org.gcube.accounting.persistence;
|
|
|
|
import java.io.File;
|
|
import java.util.Calendar;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.ServiceLoader;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import org.gcube.accounting.aggregation.scheduler.AggregationScheduler;
|
|
import org.gcube.common.scope.api.ScopeProvider;
|
|
import org.gcube.common.scope.impl.ScopeBean;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
/**
|
|
* @author Luca Frosini (ISTI - CNR) http://www.lucafrosini.com/
|
|
*
|
|
*/
|
|
public abstract class AccountingPersistenceBackendFactory {
|
|
|
|
private static final Logger logger = LoggerFactory.getLogger(AccountingPersistenceBackendFactory.class);
|
|
|
|
public final static String HOME_SYSTEM_PROPERTY = "user.home";
|
|
|
|
private static final String ACCOUTING_FALLBACK_FILENAME = "accountingFallback.log";
|
|
|
|
private static String fallbackLocation;
|
|
|
|
private static Map<String, AccountingPersistenceBackend> accountingPersistenceBackends;
|
|
private static Map<String, Long> fallbackLastCheck;
|
|
|
|
public static final long FALLBACK_RETRY_TIME = 1000*60*10; // 10 min
|
|
|
|
/**
|
|
* @return the fallbackLastCheck
|
|
*/
|
|
protected static Long getFallbackLastCheck(String scope) {
|
|
return fallbackLastCheck.get(scope);
|
|
}
|
|
|
|
static {
|
|
accountingPersistenceBackends = new HashMap<String, AccountingPersistenceBackend>();
|
|
fallbackLastCheck = new HashMap<String, Long>();
|
|
}
|
|
|
|
private static File file(File file) throws IllegalArgumentException {
|
|
if(!file.isDirectory()){
|
|
file = file.getParentFile();
|
|
}
|
|
// Create folder structure if not exist
|
|
if (!file.exists()) {
|
|
file.mkdirs();
|
|
}
|
|
return file;
|
|
}
|
|
|
|
protected synchronized static void setFallbackLocation(String path){
|
|
if(fallbackLocation == null){
|
|
if(path==null){
|
|
path = System.getProperty(HOME_SYSTEM_PROPERTY);
|
|
}
|
|
file(new File(path));
|
|
fallbackLocation = path;
|
|
}
|
|
}
|
|
|
|
protected static FallbackPersistenceBackend createFallback(String scope){
|
|
logger.debug("Creating {} for scope {}", FallbackPersistenceBackend.class.getSimpleName(), scope);
|
|
File fallbackFile = null;
|
|
if(scope!=null){
|
|
ScopeBean bean = new ScopeBean(scope);
|
|
/* if(bean.is(Type.VRE)){ bean = bean.enclosingScope(); } */
|
|
String name = bean.name();
|
|
fallbackFile = new File(fallbackLocation, String.format("%s.%s", name, ACCOUTING_FALLBACK_FILENAME));
|
|
}else{
|
|
fallbackFile = new File(fallbackLocation, ACCOUTING_FALLBACK_FILENAME);
|
|
}
|
|
FallbackPersistenceBackend fallbackPersistence = new FallbackPersistenceBackend(fallbackFile);
|
|
fallbackPersistence.setAggregationScheduler(AggregationScheduler.newInstance());
|
|
return fallbackPersistence;
|
|
}
|
|
|
|
protected static AccountingPersistenceBackend discoverAccountingPersistenceBackend(String scope){
|
|
logger.debug("Discovering {} for scope {}",
|
|
AccountingPersistenceBackend.class.getSimpleName(), scope);
|
|
ServiceLoader<AccountingPersistenceBackend> serviceLoader = ServiceLoader.load(AccountingPersistenceBackend.class);
|
|
for (AccountingPersistenceBackend foundPersistence : serviceLoader) {
|
|
try {
|
|
String foundPersistenceClassName = foundPersistence.getClass().getSimpleName();
|
|
logger.debug("Testing {}", foundPersistenceClassName);
|
|
AccountingPersistenceConfiguration configuration = new AccountingPersistenceConfiguration(foundPersistenceClassName);
|
|
foundPersistence.prepareConnection(configuration);
|
|
/*
|
|
* Uncomment the following line of code if you want to try
|
|
* to create a test UsageRecord before setting the
|
|
* foundPersistence as default
|
|
*
|
|
* foundPersistence.accountWithFallback(TestUsageRecord.createTestServiceUsageRecord());
|
|
*/
|
|
logger.debug("{} will be used.", foundPersistenceClassName);
|
|
foundPersistence.setAggregationScheduler(AggregationScheduler.newInstance());
|
|
foundPersistence.setFallback(createFallback(scope));
|
|
return foundPersistence;
|
|
} catch (Exception e) {
|
|
logger.error(String.format("%s not initialized correctly. It will not be used. Trying the next one if any.", foundPersistence.getClass().getSimpleName()), e);
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
protected static AccountingPersistenceBackend rediscoverAccountingPersistenceBackend(AccountingPersistenceBackend actual, String scope){
|
|
Long now = Calendar.getInstance().getTimeInMillis();
|
|
Long lastCheckTimestamp = fallbackLastCheck.get(scope);
|
|
logger.debug("Last check for scope {} was {}", scope, lastCheckTimestamp);
|
|
boolean myTurn = false;
|
|
synchronized (accountingPersistenceBackends) {
|
|
if( (lastCheckTimestamp + FALLBACK_RETRY_TIME) <= now ){
|
|
logger.debug("The {} for scope {} is {}. Is time to rediscover if there is another possibility.",
|
|
AccountingPersistenceBackend.class.getSimpleName(), scope, actual.getClass().getSimpleName());
|
|
logger.trace("Renewing Last check Timestamp. The next one will be {}", now);
|
|
fallbackLastCheck.put(scope, now);
|
|
myTurn=true;
|
|
logger.debug("I win. It is my turn to rediscover {} in scope {}",
|
|
AccountingPersistenceBackend.class.getSimpleName(), scope);
|
|
}
|
|
}
|
|
|
|
if(myTurn){
|
|
AccountingPersistenceBackend discoveredPersistenceBackend = discoverAccountingPersistenceBackend(scope);
|
|
|
|
synchronized (accountingPersistenceBackends) {
|
|
if(discoveredPersistenceBackend!=null){
|
|
/*
|
|
* Passing the aggregator to the new AccountingPersistenceBackend
|
|
* so that the buffered records will be persisted with the
|
|
* new method
|
|
*
|
|
*/
|
|
discoveredPersistenceBackend.setAggregationScheduler(actual.getAggregationScheduler());
|
|
|
|
// Removing timestamp which is no more needed
|
|
fallbackLastCheck.remove(scope);
|
|
accountingPersistenceBackends.put(scope, discoveredPersistenceBackend);
|
|
|
|
/*
|
|
* Not needed because close has no effect. Removed to
|
|
* prevent problem in cases of future changes.
|
|
* try {
|
|
* actual.close();
|
|
* } catch (Exception e) {
|
|
* logger.error("Error closing {} for scope {} which has been substituted with {}.",
|
|
* actual.getClass().getSimpleName(), scope,
|
|
* discoveredPersistenceBackend.getClass().getSimpleName(), e);
|
|
* }
|
|
*
|
|
*/
|
|
return discoveredPersistenceBackend;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
long nextCheck = (lastCheckTimestamp + FALLBACK_RETRY_TIME) - Calendar.getInstance().getTimeInMillis();
|
|
float nextCheckInSec = nextCheck/1000;
|
|
logger.debug("The {} for scope {} is going to be used is {}. Next retry in {} msec (about {} sec)",
|
|
AccountingPersistenceBackend.class.getSimpleName(), scope,
|
|
actual.getClass().getSimpleName(), nextCheck, nextCheckInSec);
|
|
|
|
return actual;
|
|
}
|
|
|
|
protected static AccountingPersistenceBackend getPersistenceBackend() {
|
|
String scope = ScopeProvider.instance.get();
|
|
|
|
if(scope==null){
|
|
logger.error("No Scope available. FallbackPersistence will be used");
|
|
return createFallback(null);
|
|
}
|
|
|
|
AccountingPersistenceBackend persistence = null;
|
|
logger.debug("Going to synchronized block in getPersistenceBackend");
|
|
synchronized (accountingPersistenceBackends) {
|
|
persistence = accountingPersistenceBackends.get(scope);
|
|
logger.debug("{} {}", AccountingPersistenceBackend.class.getSimpleName(), persistence);
|
|
if(persistence==null){
|
|
/*
|
|
* Setting FallbackPersistence and unlocking.
|
|
* This is used to avoid deadlock on IS node which try to use
|
|
* itself to query configuration.
|
|
*/
|
|
persistence = createFallback(scope);
|
|
accountingPersistenceBackends.put(scope, persistence);
|
|
long now = Calendar.getInstance().getTimeInMillis();
|
|
/* The AccountingPersistenceBackend is still to be discovered
|
|
* setting the last check advanced in time to force rediscover.
|
|
*/
|
|
fallbackLastCheck.put(scope, ((now - FALLBACK_RETRY_TIME) - 1));
|
|
}
|
|
}
|
|
|
|
if(persistence instanceof FallbackPersistenceBackend){
|
|
persistence = rediscoverAccountingPersistenceBackend(persistence, scope);
|
|
}
|
|
|
|
return persistence;
|
|
}
|
|
|
|
/**
|
|
* @param timeout
|
|
* @param timeUnit
|
|
* @throws Exception
|
|
*/
|
|
public static void flushAll(long timeout, TimeUnit timeUnit) {
|
|
for(String scope : accountingPersistenceBackends.keySet()){
|
|
AccountingPersistenceBackend apb = accountingPersistenceBackends.get(scope);
|
|
try {
|
|
logger.debug("Flushing records in scope {}", scope);
|
|
apb.flush(timeout, timeUnit);
|
|
}catch(Exception e){
|
|
logger.error("Unable to flush records in scope {} with {}", scope, apb);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|