224 lines
8.9 KiB
Java
224 lines
8.9 KiB
Java
package org.gcube.accounting.aggregator.plugin;
|
|
|
|
import java.text.DateFormat;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.Date;
|
|
import java.util.Map;
|
|
|
|
import org.gcube.accounting.aggregator.RegexRulesAggregator;
|
|
import org.gcube.accounting.aggregator.aggregation.AggregationType;
|
|
import org.gcube.accounting.aggregator.elaboration.AggregatorManager;
|
|
import org.gcube.accounting.aggregator.elaboration.RecoveryManager;
|
|
import org.gcube.accounting.aggregator.utility.Utility;
|
|
import org.gcube.accounting.datamodel.UsageRecord;
|
|
import org.gcube.accounting.datamodel.aggregation.AggregatedServiceUsageRecord;
|
|
import org.gcube.accounting.datamodel.usagerecords.ServiceUsageRecord;
|
|
import org.gcube.documentstore.persistence.PersistenceBackendFactory;
|
|
import org.gcube.documentstore.records.Record;
|
|
import org.gcube.documentstore.records.RecordUtility;
|
|
import org.gcube.vremanagement.executor.plugin.Plugin;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
/**
|
|
* @author Alessandro Pieve (ISTI - CNR)
|
|
* @author Luca Frosini (ISTI - CNR)
|
|
*/
|
|
public class AccountingAggregatorPlugin extends Plugin {
|
|
|
|
private static Logger logger = LoggerFactory.getLogger(AccountingAggregatorPlugin.class);
|
|
|
|
static {
|
|
/// One Record per package is enough
|
|
RecordUtility.addRecordPackage(ServiceUsageRecord.class.getPackage());
|
|
RecordUtility.addRecordPackage(AggregatedServiceUsageRecord.class.getPackage());
|
|
}
|
|
|
|
public static final String NAME = "Accounting-Aggregator-Plugin";
|
|
|
|
/**
|
|
* Key to indicate {@link AggregationType}
|
|
*/
|
|
public static final String AGGREGATION_TYPE_INPUT_PARAMETER = "aggregationType";
|
|
|
|
/**
|
|
* Day is ignored for MONTHLY aggregation
|
|
* Month and Day are ignored for YEARLY aggregation
|
|
*/
|
|
public static final String AGGREGATION_START_DATE_INPUT_PARAMETER = "aggregationStartDate";
|
|
public static final String AGGREGATION_END_DATE_INPUT_PARAMETER = "aggregationEndDate";
|
|
|
|
public static final String RESTART_FROM_LAST_AGGREGATION_DATE_INPUT_PARAMETER = "restartFromLastAggregationDate";
|
|
|
|
public static final String AGGREGATION_START_DATE_DATE_FORMAT_PATTERN = "yyyy/MM/dd";
|
|
public static final DateFormat AGGREGATION_START_DATE_DATE_FORMAT;
|
|
|
|
private static final String AGGREGATION_START_END_DATE_UTC_DATE_FORMAT_PATTERN = "yyyy/MM/dd Z";
|
|
private static final DateFormat AGGREGATION_START_END_DATE_UTC_DATE_FORMAT;
|
|
private static final String UTC = "+0000";
|
|
|
|
public static final String FORCE_EARLY_AGGREGATION = "forceEarlyAggregation";
|
|
public static final String FORCE_RERUN = "forceRerun";
|
|
public static final String FORCE_RESTART = "forceRestart";
|
|
|
|
public enum ElaborationType {
|
|
AGGREGATE, // Aggregate
|
|
RECOVERY // Recover unterminated executions
|
|
}
|
|
|
|
/**
|
|
* Indicate which types of elaboration the plugin must perform
|
|
*/
|
|
public static final String ELABORATION_TYPE_INPUT_PARAMETER = "elaborationType";
|
|
|
|
// public static final String PERSIST_START_TIME_INPUT_PARAMETER = "persistStartTime";
|
|
// public static final String PERSIST_END_TIME_INPUT_PARAMETER = "persistEndTime";
|
|
// public static final String PERSIST_TIME_DATE_FORMAT_PATTERN = "HH:mm";
|
|
// public static final DateFormat PERSIST_TIME_DATE_FORMAT;
|
|
|
|
public static final String LOCAL_TIME_DATE_FORMAT_PATTERN = "HH:mm Z";
|
|
public static final DateFormat LOCAL_TIME_DATE_FORMAT;
|
|
|
|
public static final String RECORD_TYPE_INPUT_PARAMETER = Record.RECORD_TYPE;
|
|
|
|
static {
|
|
AGGREGATION_START_DATE_DATE_FORMAT = Utility.getUTCDateFormat(AGGREGATION_START_DATE_DATE_FORMAT_PATTERN);
|
|
AGGREGATION_START_END_DATE_UTC_DATE_FORMAT = Utility.getUTCDateFormat(AGGREGATION_START_END_DATE_UTC_DATE_FORMAT_PATTERN);
|
|
|
|
// PERSIST_TIME_DATE_FORMAT = new SimpleDateFormat(PERSIST_TIME_DATE_FORMAT_PATTERN);
|
|
|
|
LOCAL_TIME_DATE_FORMAT = new SimpleDateFormat(LOCAL_TIME_DATE_FORMAT_PATTERN);
|
|
}
|
|
|
|
public AccountingAggregatorPlugin() {
|
|
super();
|
|
RegexRulesAggregator.getInstance();
|
|
}
|
|
|
|
// private Date getPersistTime(Map<String, Object> inputs, String parameterName) throws ParseException{
|
|
// Date persistTime = null;
|
|
// if (inputs.containsKey(parameterName)) {
|
|
// String persistTimeString = (String) inputs.get(parameterName);
|
|
// persistTime = Utility.getPersistTimeDate(persistTimeString);
|
|
// }
|
|
//
|
|
// if(persistTime==null){
|
|
// throw new IllegalArgumentException("Please set a valid '" + parameterName +"' by using " + PERSIST_TIME_DATE_FORMAT_PATTERN + " format.");
|
|
// }
|
|
//
|
|
// return persistTime;
|
|
// }
|
|
|
|
/** {@inheritDoc} */
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public void launch(Map<String, Object> inputs) throws Exception {
|
|
PersistenceBackendFactory.getPersistenceBackend(Utility.getCurrentContext());
|
|
|
|
AggregationType aggregationType = null;
|
|
Date aggregationStartDate = null;
|
|
Date aggregationEndDate = null;
|
|
boolean restartFromLastAggregationDate = false;
|
|
ElaborationType elaborationType = ElaborationType.AGGREGATE;
|
|
|
|
String recordType = null;
|
|
Class<? extends UsageRecord> usageRecordClass = null;
|
|
|
|
boolean forceEarlyAggregation = false;
|
|
boolean forceRerun = false;
|
|
boolean forceRestart = false;
|
|
|
|
if (inputs == null || inputs.isEmpty()) {
|
|
throw new IllegalArgumentException("The can only be launched providing valid input parameters");
|
|
}
|
|
|
|
if (inputs.containsKey(ELABORATION_TYPE_INPUT_PARAMETER)) {
|
|
elaborationType = ElaborationType.valueOf((String) inputs.get(ELABORATION_TYPE_INPUT_PARAMETER));
|
|
}
|
|
|
|
// Date persistStartTime = getPersistTime(inputs, PERSIST_START_TIME_INPUT_PARAMETER);
|
|
// Date persistEndTime = getPersistTime(inputs, PERSIST_END_TIME_INPUT_PARAMETER);
|
|
|
|
if (inputs.containsKey(AGGREGATION_START_DATE_INPUT_PARAMETER)) {
|
|
String aggregationStartDateString = (String) inputs.get(AGGREGATION_START_DATE_INPUT_PARAMETER);
|
|
aggregationStartDateString = aggregationStartDateString + " " + UTC;
|
|
aggregationStartDate = AGGREGATION_START_END_DATE_UTC_DATE_FORMAT.parse(aggregationStartDateString);
|
|
}
|
|
|
|
if (inputs.containsKey(AGGREGATION_END_DATE_INPUT_PARAMETER)) {
|
|
String aggregationEndDateString = (String) inputs.get(AGGREGATION_END_DATE_INPUT_PARAMETER);
|
|
aggregationEndDateString = aggregationEndDateString + " " + UTC;
|
|
aggregationEndDate = AGGREGATION_START_END_DATE_UTC_DATE_FORMAT.parse(aggregationEndDateString);
|
|
}
|
|
|
|
if(inputs.containsKey(FORCE_RESTART)) {
|
|
forceRestart = (boolean) inputs.get(FORCE_RESTART);
|
|
}
|
|
|
|
if(inputs.containsKey(AGGREGATION_TYPE_INPUT_PARAMETER)) {
|
|
aggregationType = AggregationType.valueOf((String) inputs.get(AGGREGATION_TYPE_INPUT_PARAMETER));
|
|
}
|
|
|
|
if (inputs.containsKey(RECORD_TYPE_INPUT_PARAMETER)) {
|
|
recordType = (String) inputs.get(RECORD_TYPE_INPUT_PARAMETER);
|
|
usageRecordClass = (Class<? extends UsageRecord>) RecordUtility.getRecordClass(recordType);
|
|
logger.debug("Requested record type is {} which is implemented by {}", recordType, usageRecordClass);
|
|
}
|
|
|
|
switch (elaborationType) {
|
|
case AGGREGATE:
|
|
if (!inputs.containsKey(AGGREGATION_TYPE_INPUT_PARAMETER)) {
|
|
throw new IllegalArgumentException("Please set required parameter '" + AGGREGATION_TYPE_INPUT_PARAMETER +"'");
|
|
}
|
|
|
|
if(inputs.containsKey(RESTART_FROM_LAST_AGGREGATION_DATE_INPUT_PARAMETER)){
|
|
restartFromLastAggregationDate = (boolean) inputs.get(RESTART_FROM_LAST_AGGREGATION_DATE_INPUT_PARAMETER);
|
|
}
|
|
|
|
if(inputs.containsKey(FORCE_EARLY_AGGREGATION)) {
|
|
forceEarlyAggregation = (boolean) inputs.get(FORCE_EARLY_AGGREGATION);
|
|
}
|
|
|
|
if(inputs.containsKey(FORCE_RERUN)) {
|
|
forceRerun = (boolean) inputs.get(FORCE_RERUN);
|
|
}
|
|
|
|
if(restartFromLastAggregationDate==false && aggregationStartDate==null){
|
|
throw new IllegalArgumentException("Aggregation Start Date cannot be found. Please provide it as parameter or set '" + RESTART_FROM_LAST_AGGREGATION_DATE_INPUT_PARAMETER + "' input parameter to 'true'.");
|
|
}
|
|
|
|
AggregatorManager aggregatorManager = new AggregatorManager(aggregationType, restartFromLastAggregationDate, aggregationStartDate, aggregationEndDate);
|
|
aggregatorManager.setForceEarlyAggregation(forceEarlyAggregation);
|
|
aggregatorManager.setForceRerun(forceRerun);
|
|
aggregatorManager.setForceRestart(forceRestart);
|
|
// aggregatorManager.elaborate(persistStartTime, persistEndTime, recordType);
|
|
aggregatorManager.elaborate(recordType);
|
|
|
|
break;
|
|
|
|
case RECOVERY:
|
|
// RecoveryManager recoveryManager = new RecoveryManager(persistStartTime, persistEndTime, aggregationStartDate, aggregationEndDate);
|
|
RecoveryManager recoveryManager = new RecoveryManager(aggregationStartDate, aggregationEndDate);
|
|
recoveryManager.setForceRestart(forceRestart);
|
|
recoveryManager.setRecordType(recordType);
|
|
recoveryManager.setAggregationType(aggregationType);
|
|
recoveryManager.recovery();
|
|
break;
|
|
|
|
default:
|
|
throw new IllegalArgumentException("No ElaborationType provided. You should not be here. Please Contact the administrator");
|
|
}
|
|
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
@Override
|
|
protected void onStop() throws Exception {
|
|
logger.trace("Stopping execution of {}, UUID : {}", getName(), this.uuid);
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
|
|
|
|
|
|
}
|