diff --git a/pom.xml b/pom.xml index b713cc2..35f10b0 100644 --- a/pom.xml +++ b/pom.xml @@ -10,7 +10,7 @@ org.gcube.accounting accounting-lib - 2.3.0-SNAPSHOT + 2.4.0-SNAPSHOT Accounting Library Accounting Library jar diff --git a/src/main/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageStatusRecord.java b/src/main/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageStatusRecord.java new file mode 100644 index 0000000..43cc934 --- /dev/null +++ b/src/main/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageStatusRecord.java @@ -0,0 +1,164 @@ +/** + * + */ +package org.gcube.accounting.datamodel.aggregation; + +import java.io.Serializable; +import java.util.Calendar; +import java.util.Map; + +import org.gcube.accounting.datamodel.AggregatedUsageRecord; +import org.gcube.accounting.datamodel.basetypes.AbstractStorageStatusRecord; +import org.gcube.accounting.datamodel.usagerecords.StorageStatusRecord; +import org.gcube.documentstore.exception.InvalidValueException; +import org.gcube.documentstore.exception.NotAggregatableRecordsExceptions; +import org.gcube.documentstore.records.aggregation.AggregationUtility; +import org.gcube.documentstore.records.implementation.AggregatedField; + +/** + * This Class is for library internal use only + * @author Alessandro Pieve (ISTI - CNR) alessandro.pieve@isti.cnr.it + */ +public class AggregatedStorageStatusRecord extends AbstractStorageStatusRecord implements AggregatedUsageRecord { + + /** + * Generated Serial Version UID + */ + private static final long serialVersionUID = 4683337274367137236L; + + @AggregatedField + public static final String DATA_VOLUME = AbstractStorageStatusRecord.DATA_VOLUME; + + @AggregatedField + public static final String DATA_COUNT = AbstractStorageStatusRecord.DATA_COUNT; + + + public AggregatedStorageStatusRecord() { + super(); + } + + public AggregatedStorageStatusRecord(Map properties) throws InvalidValueException{ + super(properties); + } + + public AggregatedStorageStatusRecord(StorageStatusRecord record) throws InvalidValueException{ + super(record.getResourceProperties()); + this.setOperationCount(1); + Calendar creationTime = record.getCreationTime(); + this.setCreationTime(Calendar.getInstance()); + this.setStartTime(creationTime); + this.setEndTime(creationTime); + } + + @Override + public int getOperationCount() { + return super.getOperationCount(); + } + + @Override + public void setOperationCount(int operationCount) throws InvalidValueException { + super.setOperationCount(operationCount); + } + + /** + * {@inheritDoc} + */ + @Override + public Calendar getStartTime() { + return super.getStartTimeAsCalendar(); + } + + /** + * {@inheritDoc} + */ + @Override + public void setStartTime(Calendar startTime) throws InvalidValueException { + super.setStartTime(startTime); + } + + /** + * {@inheritDoc} + */ + @Override + public Calendar getEndTime() { + return super.getEndTimeAsCalendar(); + } + + /** + * {@inheritDoc} + */ + @Override + public void setEndTime(Calendar endTime) throws InvalidValueException { + super.setEndTime(endTime); + } + + /** + * {@inheritDoc} + */ + @Override + public AggregatedStorageStatusRecord aggregate( + AggregatedStorageStatusRecord record) + throws NotAggregatableRecordsExceptions { + try { + AggregationUtility aggregationUtility = new AggregationUtility(this); + aggregationUtility.aggregate(record); + this.setDataVolume(record.getDataVolume()); + this.setDataCount(record.getDataCount()); + + }catch(NotAggregatableRecordsExceptions e){ + throw e; + } catch(Exception ex){ + throw new NotAggregatableRecordsExceptions(ex); + } + return this; + } + + /** + * {@inheritDoc} + */ + @Override + public AggregatedStorageStatusRecord aggregate(StorageStatusRecord record) + throws NotAggregatableRecordsExceptions { + try { + return aggregate(new AggregatedStorageStatusRecord(record)); + } catch(NotAggregatableRecordsExceptions e){ + throw e; + } catch(Exception ex){ + throw new NotAggregatableRecordsExceptions(ex); + } + } + + /** + * {@inheritDoc} + */ + @Override + public boolean isAggregable(AggregatedStorageStatusRecord record) + throws NotAggregatableRecordsExceptions { + AggregationUtility aggregationUtility = new AggregationUtility(this); + return aggregationUtility.isAggregable(record); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean isAggregable(StorageStatusRecord record) + throws NotAggregatableRecordsExceptions { + try { + return isAggregable(new AggregatedStorageStatusRecord(record)); + } catch(NotAggregatableRecordsExceptions e){ + throw e; + } catch(Exception ex){ + throw new NotAggregatableRecordsExceptions(ex); + } + } + + /** + * {@inheritDoc} + */ + @Override + public Class getAggregable() { + return StorageStatusRecord.class; + } + +} diff --git a/src/main/java/org/gcube/accounting/datamodel/basetypes/AbstractStorageStatusRecord.java b/src/main/java/org/gcube/accounting/datamodel/basetypes/AbstractStorageStatusRecord.java new file mode 100644 index 0000000..acf00a7 --- /dev/null +++ b/src/main/java/org/gcube/accounting/datamodel/basetypes/AbstractStorageStatusRecord.java @@ -0,0 +1,153 @@ +/** + * + */ +package org.gcube.accounting.datamodel.basetypes; + +import java.io.Serializable; +import java.net.URI; +import java.util.Map; + +import org.gcube.accounting.datamodel.BasicUsageRecord; +import org.gcube.accounting.datamodel.validations.annotations.FixDataVolumeSign; +import org.gcube.accounting.datamodel.validations.annotations.ValidDataType; +import org.gcube.accounting.datamodel.validations.annotations.ValidURI; +import org.gcube.documentstore.exception.InvalidValueException; +import org.gcube.documentstore.records.implementation.RequiredField; +import org.gcube.documentstore.records.implementation.validations.annotations.NotEmpty; +import org.gcube.documentstore.records.implementation.validations.annotations.ValidLong; + +/** + * @author Alessandro Pieve (ISTI - CNR) alessandro.pieve@isti.cnr.it + * + */ +public abstract class AbstractStorageStatusRecord extends BasicUsageRecord { + + /** + * Generated Serial Version UID + */ + private static final long serialVersionUID = -5754343539116896036L; + + public enum DataType { + STORAGE, TREE, GEO, DATABASE, OTHER + } + + /** + * KEY for : Quantity of data in terms of KB + */ + @RequiredField @ValidLong @FixDataVolumeSign + public static final String DATA_VOLUME = "dataVolume"; + + /** + * KEY for : type of data accessed. + * The value is a controlled dictionary by + * {@link #StorageStatusRecord.DataType} + */ + @RequiredField @ValidDataType + public static final String DATA_TYPE = "dataType"; + + /** + * KEY for : data Count number of objects + */ + @RequiredField @NotEmpty + public static final String DATA_COUNT = "dataCount"; + + /** + * KEY for : data service class identifier + */ + @RequiredField @NotEmpty + public static final String DATA_SERVICECLASS = "dataServiceClass"; + + /** + * KEY for : data service name identifier + */ + @RequiredField @NotEmpty + public static final String DATA_SERVICENAME = "dataServiceName"; + + /** + * KEY for : data service name id + */ + @RequiredField @NotEmpty + public static final String DATA_SERVICEID = "dataServiceId"; + + /** + * KEY for : providerId the identifier of the provider which is the target of a read/write operation + */ + @RequiredField @ValidURI + public static final String PROVIDER_ID = "providerId"; + + + public AbstractStorageStatusRecord() { + super(); + } + + public AbstractStorageStatusRecord(Map properties) throws InvalidValueException { + super(properties); + } + + private static final String ABSTRACT_TO_REPLACE = "Abstract"; + + /** + * {@inheritDoc} + */ + @Override + protected String giveMeRecordType() { + return AbstractStorageStatusRecord.class.getSimpleName().replace(ABSTRACT_TO_REPLACE, ""); + } + + public long getDataVolume() { + return (Long) this.resourceProperties.get(DATA_VOLUME); + } + + public void setDataVolume(long dataVolume) throws InvalidValueException { + setResourceProperty(DATA_VOLUME, dataVolume); + } + + public DataType getDataType() { + return (DataType) this.resourceProperties.get(DATA_TYPE); + } + + public void setDataType(DataType dataType) throws InvalidValueException { + setResourceProperty(DATA_TYPE, dataType); + } + + public long getDataCount() { + return (Long) this.resourceProperties.get(DATA_COUNT); + } + + public void setDataCount(long dataCount) throws InvalidValueException { + setResourceProperty(DATA_COUNT, dataCount); + } + + public String getDataServiceClass() { + return (String) this.resourceProperties.get(DATA_SERVICECLASS); + } + + public void setDataServiceClass(String dataServiceClass) throws InvalidValueException { + setResourceProperty(DATA_SERVICECLASS, dataServiceClass); + } + + public String getDataServiceName() { + return (String) this.resourceProperties.get(DATA_SERVICENAME); + } + + public void setDataServiceName(String dataServiceName) throws InvalidValueException { + setResourceProperty(DATA_SERVICENAME, dataServiceName); + } + + public String getDataServiceId() { + return (String) this.resourceProperties.get(DATA_SERVICEID); + } + + public void setDataServiceId(String dataServiceId) throws InvalidValueException { + setResourceProperty(DATA_SERVICEID, dataServiceId); + } + + public URI getProviderId() { + return (URI) this.resourceProperties.get(PROVIDER_ID); + } + + public void setProviderId(URI provideId) throws InvalidValueException { + setResourceProperty(PROVIDER_ID, provideId); + } + +} diff --git a/src/main/java/org/gcube/accounting/datamodel/usagerecords/StorageStatusRecord.java b/src/main/java/org/gcube/accounting/datamodel/usagerecords/StorageStatusRecord.java new file mode 100644 index 0000000..9cfa7d4 --- /dev/null +++ b/src/main/java/org/gcube/accounting/datamodel/usagerecords/StorageStatusRecord.java @@ -0,0 +1,26 @@ +package org.gcube.accounting.datamodel.usagerecords; + +import java.io.Serializable; +import java.util.Map; + +import org.gcube.accounting.datamodel.basetypes.AbstractStorageStatusRecord; +import org.gcube.documentstore.exception.InvalidValueException; +/** + * @author Alessandro Pieve (ISTI - CNR) alessandro.pieve@isti.cnr.it + * + */ +public class StorageStatusRecord extends AbstractStorageStatusRecord { + + /** + * Generated Serial Version UID + */ + private static final long serialVersionUID = 8174719617939936365L; + + public StorageStatusRecord() { + super(); + } + + public StorageStatusRecord(Map properties) throws InvalidValueException { + super(properties); + } +} diff --git a/src/test/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageStatusRecordTest.java b/src/test/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageStatusRecordTest.java new file mode 100644 index 0000000..76617ac --- /dev/null +++ b/src/test/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageStatusRecordTest.java @@ -0,0 +1,168 @@ +/** + * + */ +package org.gcube.accounting.datamodel.aggregation; + +import java.util.Set; + + +import org.gcube.accounting.datamodel.usagerecords.StorageStatusRecord; +import org.gcube.accounting.datamodel.usagerecords.StorageStatusRecordTest; +import org.gcube.documentstore.exception.InvalidValueException; +import org.gcube.documentstore.exception.NotAggregatableRecordsExceptions; +import org.gcube.testutility.ScopedTest; +import org.gcube.testutility.TestUsageRecord; +import org.junit.Assert; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * @author Alessandro Pieve (ISTI - CNR) alessandro.pieve@isti.cnr.it + * + */ +public class AggregatedStorageStatusRecordTest extends ScopedTest { + + private static Logger logger = LoggerFactory.getLogger(AggregatedStorageStatusRecordTest.class); + + @Test + public void testRequiredFields() throws InvalidValueException { + StorageStatusRecord storageVolumeUsageRecord = TestUsageRecord.createTestStorageVolumeUsageRecord(); + Assert.assertTrue(storageVolumeUsageRecord.getScope()==null); + storageVolumeUsageRecord.setScope(TestUsageRecord.TEST_SCOPE); + + AggregatedStorageStatusRecord aggregatedStorageUsageRecord = new AggregatedStorageStatusRecord(storageVolumeUsageRecord); + + Set expectedRequiredFields = StorageStatusRecordTest.getExpectedRequiredFields(); + expectedRequiredFields.addAll(AggregatedUsageRecordTest.getExpectedRequiredFields()); + + logger.debug("Expected Required Fields : {}", expectedRequiredFields); + + Set gotRequiredFields = aggregatedStorageUsageRecord.getRequiredFields(); + + logger.debug("Got Required Fields : {}", gotRequiredFields); + + Assert.assertTrue(expectedRequiredFields.containsAll(gotRequiredFields)); + Assert.assertTrue(gotRequiredFields.containsAll(expectedRequiredFields)); + + } + + @Test + public void secondAsNotAggregated() throws InvalidValueException, NotAggregatableRecordsExceptions { + StorageStatusRecord storageVolumeUsageRecord = TestUsageRecord.createTestStorageVolumeUsageRecord(); + Assert.assertTrue(storageVolumeUsageRecord.getScope()==null); + storageVolumeUsageRecord.setScope(TestUsageRecord.TEST_SCOPE); + + storageVolumeUsageRecord.setResourceProperty(TestUsageRecord.TEST_PROPERTY_NAME, TestUsageRecord.TEST_PROPERTY_VALUE); + storageVolumeUsageRecord.validate(); + logger.debug("StorageVolumeUsageRecord : {}", storageVolumeUsageRecord); + + AggregatedStorageStatusRecord aggregated = new AggregatedStorageStatusRecord(storageVolumeUsageRecord); + logger.debug("StorageVolumeUsageRecord Converted to Aggregated: {}", aggregated); + aggregated.validate(); + + StorageStatusRecord storageVolumeUsageRecord2 = TestUsageRecord.createTestStorageVolumeUsageRecord(); + storageVolumeUsageRecord2.setScope(TestUsageRecord.TEST_SCOPE); + + storageVolumeUsageRecord2.validate(); + logger.debug("StorageVolumeUsageRecord 2 : {}", storageVolumeUsageRecord2); + + + long secondDataVolume = storageVolumeUsageRecord2.getDataVolume(); + + long secondDataCount = storageVolumeUsageRecord2.getDataCount(); + + aggregated.aggregate(storageVolumeUsageRecord2); + logger.debug("Resulting Aggregated StorageVolumeUsageRecord: {}", aggregated); + aggregated.validate(); + + Assert.assertTrue(aggregated.getDataVolume() == (secondDataVolume)); + Assert.assertTrue(aggregated.getDataCount() == (secondDataCount)); + Assert.assertTrue(aggregated.getOperationCount() == 2); + Assert.assertFalse(aggregated.getResourceProperties().containsKey(TestUsageRecord.TEST_PROPERTY_NAME)); + } + + @Test + public void secondAsAggregated() throws InvalidValueException, NotAggregatableRecordsExceptions { + StorageStatusRecord storageStatusUsageRecord = TestUsageRecord.createTestStorageVolumeUsageRecord(); + Assert.assertTrue(storageStatusUsageRecord.getScope()==null); + storageStatusUsageRecord.setScope(TestUsageRecord.TEST_SCOPE); + storageStatusUsageRecord.validate(); + logger.debug("StorageVolumeUsageRecord : {}", storageStatusUsageRecord); + + AggregatedStorageStatusRecord aggregated = new AggregatedStorageStatusRecord(storageStatusUsageRecord); + logger.debug("StorageVolumeUsageRecord Converted to Aggregated: {}", aggregated); + aggregated.validate(); + + StorageStatusRecord storageVolumeUsageRecord2 = TestUsageRecord.createTestStorageVolumeUsageRecord(); + Assert.assertTrue(storageVolumeUsageRecord2.getScope()==null); + storageVolumeUsageRecord2.setScope(TestUsageRecord.TEST_SCOPE); + storageVolumeUsageRecord2.setResourceProperty(TestUsageRecord.TEST_PROPERTY_NAME, TestUsageRecord.TEST_PROPERTY_VALUE); + storageVolumeUsageRecord2.validate(); + logger.debug("StorageVolumeUsageRecord 2 : {}", storageVolumeUsageRecord2); + AggregatedStorageStatusRecord converted = new AggregatedStorageStatusRecord(storageVolumeUsageRecord2); + logger.debug("StorageVolumeUsageRecord Converted to Aggregated: {}", converted); + converted.validate(); + + long firstDataVolume = aggregated.getDataVolume(); + long secondDataVolume = converted.getDataVolume(); + + long secondDataCount =storageVolumeUsageRecord2.getDataCount(); + + aggregated.aggregate(converted); + logger.debug("Resulting Aggregated StorageVolumeUsageRecord: {}", aggregated); + aggregated.validate(); + + Assert.assertTrue(aggregated.getDataVolume() == (secondDataVolume)); + Assert.assertTrue(aggregated.getDataCount() == (secondDataCount)); + Assert.assertTrue(aggregated.getOperationCount() == 2); + Assert.assertFalse(aggregated.getResourceProperties().containsKey(TestUsageRecord.TEST_PROPERTY_NAME)); + } + + @Test + public void aggregationStressTest() throws InvalidValueException, NotAggregatableRecordsExceptions { + StorageStatusRecord storageVolumeUsageRecord = TestUsageRecord.createTestStorageVolumeUsageRecord(); + Assert.assertTrue(storageVolumeUsageRecord.getScope()==null); + storageVolumeUsageRecord.setScope(TestUsageRecord.TEST_SCOPE); + storageVolumeUsageRecord.setResourceProperty(TestUsageRecord.TEST_PROPERTY_NAME, TestUsageRecord.TEST_PROPERTY_VALUE); + storageVolumeUsageRecord.validate(); + logger.debug("StorageVolumeUsageRecord : {}", storageVolumeUsageRecord); + + AggregatedStorageStatusRecord aggregated = new AggregatedStorageStatusRecord(storageVolumeUsageRecord); + logger.debug("StorageVolumeUsageRecord Converted to Aggregated: {}", aggregated); + aggregated.validate(); + + for(int i=2; i<10; i++){ + + StorageStatusRecord sur = TestUsageRecord.createTestStorageVolumeUsageRecord(); + sur.setScope(TestUsageRecord.TEST_SCOPE); + sur.setResourceProperty(TestUsageRecord.TEST_PROPERTY_NAME, TestUsageRecord.TEST_PROPERTY_VALUE); + sur.validate(); + logger.debug("Cycle StorageVolumeUsageRecord {}: {}", i, sur); + + //long oldDataVolume = aggregated.getDataVolume(); + long newDataVolume = sur.getDataVolume(); + + + //long oldDataCount = aggregated.getDataCount(); + long newDataCount = sur.getDataCount(); + + aggregated.aggregate(sur); + logger.debug("Resulting Aggregated StorageUsageRecord : {}", aggregated); + aggregated.validate(); + + Assert.assertTrue(aggregated.getDataVolume() == (newDataVolume)); + Assert.assertTrue(aggregated.getDataCount() == (newDataCount)); + Assert.assertTrue(aggregated.getOperationCount() == i); + Assert.assertFalse(aggregated.getResourceProperties().containsKey(TestUsageRecord.TEST_PROPERTY_NAME)); + } + + logger.debug("Resulting Aggregated StorageUsageRecord: {}", aggregated); + } + + + + + + +} diff --git a/src/test/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageUsageRecordTest.java b/src/test/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageUsageRecordTest.java index 1d05076..c1e400f 100644 --- a/src/test/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageUsageRecordTest.java +++ b/src/test/java/org/gcube/accounting/datamodel/aggregation/AggregatedStorageUsageRecordTest.java @@ -148,4 +148,9 @@ public class AggregatedStorageUsageRecordTest extends ScopedTest { logger.debug("Resulting Aggregated StorageUsageRecord: {}", aggregated); } + + + + + } diff --git a/src/test/java/org/gcube/accounting/datamodel/usagerecords/StorageStatusRecordTest.java b/src/test/java/org/gcube/accounting/datamodel/usagerecords/StorageStatusRecordTest.java new file mode 100644 index 0000000..1277eae --- /dev/null +++ b/src/test/java/org/gcube/accounting/datamodel/usagerecords/StorageStatusRecordTest.java @@ -0,0 +1,73 @@ +/** + * + */ +package org.gcube.accounting.datamodel.usagerecords; + +import java.util.HashSet; +import java.util.Set; + +import org.gcube.accounting.datamodel.UsageRecord; +import org.gcube.accounting.datamodel.basetypes.AbstractStorageStatusRecord; +import org.gcube.documentstore.exception.InvalidValueException; +import org.gcube.documentstore.records.Record; +import org.gcube.testutility.ScopedTest; +import org.gcube.testutility.TestUsageRecord; +import org.junit.Assert; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * @author Alessandro Pieve (ISTI - CNR) alessandro.pieve@isti.cnr.it + * + */ +public class StorageStatusRecordTest extends ScopedTest { + + private static Logger logger = LoggerFactory.getLogger(StorageStatusRecordTest.class); + + public static Set getExpectedRequiredFields(){ + Set expectedRequiredFields = new HashSet(); + expectedRequiredFields.add(Record.ID); + expectedRequiredFields.add(UsageRecord.CONSUMER_ID); + expectedRequiredFields.add(UsageRecord.CREATION_TIME); + expectedRequiredFields.add(UsageRecord.RECORD_TYPE); + expectedRequiredFields.add(UsageRecord.SCOPE); + expectedRequiredFields.add(UsageRecord.OPERATION_RESULT); + expectedRequiredFields.add(AbstractStorageStatusRecord.DATA_VOLUME); + expectedRequiredFields.add(AbstractStorageStatusRecord.DATA_COUNT); + expectedRequiredFields.add(AbstractStorageStatusRecord.DATA_TYPE); + expectedRequiredFields.add(AbstractStorageStatusRecord.DATA_SERVICECLASS); + expectedRequiredFields.add(AbstractStorageStatusRecord.DATA_SERVICENAME); + expectedRequiredFields.add(AbstractStorageStatusRecord.DATA_SERVICEID); + expectedRequiredFields.add(AbstractStorageStatusRecord.PROVIDER_ID); + + return expectedRequiredFields; + } + + @Test(expected=InvalidValueException.class) + public void scopeNotSetValidationError() throws InvalidValueException { + StorageStatusRecord usageRecord = TestUsageRecord.createTestStorageVolumeUsageRecord(); + usageRecord.validate(); + logger.debug("{}", usageRecord); + } + + @Test + public void testRequiredFields() throws InvalidValueException{ + StorageStatusRecord usageRecord = TestUsageRecord.createTestStorageVolumeUsageRecord(); + Assert.assertTrue(usageRecord.getScope()==null); + usageRecord.setScope(TestUsageRecord.TEST_SCOPE); + + Set expectedRequiredFields = getExpectedRequiredFields(); + logger.debug("Expected Required Fields : {}", expectedRequiredFields); + + Set gotRequiredFields = usageRecord.getRequiredFields(); + logger.debug("Got Required Fields : {}", gotRequiredFields); + + Assert.assertTrue(expectedRequiredFields.containsAll(gotRequiredFields)); + Assert.assertTrue(gotRequiredFields.containsAll(expectedRequiredFields)); + + usageRecord.validate(); + logger.debug("{}", usageRecord); + } + +} diff --git a/src/test/java/org/gcube/testutility/TestUsageRecord.java b/src/test/java/org/gcube/testutility/TestUsageRecord.java index 7a9d478..63d38f8 100644 --- a/src/test/java/org/gcube/testutility/TestUsageRecord.java +++ b/src/test/java/org/gcube/testutility/TestUsageRecord.java @@ -12,10 +12,12 @@ import java.util.UUID; import org.gcube.accounting.datamodel.UsageRecord.OperationResult; import org.gcube.accounting.datamodel.basetypes.AbstractStorageUsageRecord; +import org.gcube.accounting.datamodel.basetypes.AbstractStorageStatusRecord; import org.gcube.accounting.datamodel.usagerecords.JobUsageRecord; import org.gcube.accounting.datamodel.usagerecords.PortletUsageRecord; import org.gcube.accounting.datamodel.usagerecords.ServiceUsageRecord; import org.gcube.accounting.datamodel.usagerecords.StorageUsageRecord; +import org.gcube.accounting.datamodel.usagerecords.StorageStatusRecord; import org.gcube.accounting.datamodel.usagerecords.TaskUsageRecord; import org.gcube.accounting.persistence.AccountingPersistenceFactory; import org.gcube.documentstore.exception.InvalidValueException; @@ -29,42 +31,43 @@ import org.slf4j.LoggerFactory; public class TestUsageRecord { private static final Logger logger = LoggerFactory.getLogger(TestUsageRecord.class); - + public final static String TEST_CONSUMER_ID = "name.surname"; public final static String TEST_SCOPE = "/infrastructure/vo"; + public final static String TEST_SCOPE_2 = "/infrastructure/vo/vre"; public final static OperationResult TEST_OPERATION_RESULT = OperationResult.SUCCESS; - + public final static String TEST_SERVICE_CLASS = "TestServiceClass"; public final static String TEST_SERVICE_NAME = "TestServiceName"; public final static String TEST_CALLED_METHOD = "TestCalledMethod"; public final static String TEST_CALLER_QUALIFIER = "TestCallerQualifier"; - + public final static String TEST_CALLER_HOST = "remotehost"; public final static String TEST_HOST = "localhost"; - + public final static String TEST_PROPERTY_NAME = "TestPropertyName"; public final static String TEST_PROPERTY_VALUE = "TestPropertyValue"; - + public final static String TEST_JOB_ID = UUID.randomUUID().toString(); public final static String TEST_JOB_NAME = "TestJobName"; public final static int TEST_VMS_USED = 2; public final static String TEST_JOB_QUALIFIER = "TestJobQualifier"; public final static long HALF_DURATION = 10 * 60 * 1000; // 10 min - + public final static String TEST_TASK_ID = UUID.randomUUID().toString(); public final static String TEST_NESTED_MAP = "TestNestedMap"; - + public final static String TEST_PORTLET_ID = "TestPortlet"; public final static String TEST_PORTLET_OPERATION_ID = "TestPortletOperationID"; public final static String TEST_PORTLET_MESSAGE = "TestPortletMessage"; - + private final static long MIN_DURATION = 60; // millisec private final static long MAX_DURATION = 1000; // millisec - + static { AccountingPersistenceFactory.initAccountingPackages(); } - + /** * Generate A Random long in a range between min and max. * This function is internally used to set random duration. @@ -73,7 +76,7 @@ public class TestUsageRecord { public static long generateRandomLong(long min, long max){ return min + (int)(Math.random() * ((max - min) + 1)); } - + /** * Create a valid #ServiceUsageRecord with scope set automatically. * @return the created #ServiceUsageRecord @@ -83,29 +86,29 @@ public class TestUsageRecord { try { usageRecord.setConsumerId(TEST_CONSUMER_ID); usageRecord.setOperationResult(TEST_OPERATION_RESULT); - + usageRecord.setCallerHost(TEST_CALLER_HOST); usageRecord.setHost(TEST_HOST); usageRecord.setCallerQualifier(TEST_CALLER_QUALIFIER); usageRecord.setServiceClass(TEST_SERVICE_CLASS); usageRecord.setServiceName(TEST_SERVICE_NAME); usageRecord.setCalledMethod(TEST_CALLED_METHOD); - + usageRecord.setDuration(generateRandomLong(MIN_DURATION, MAX_DURATION)); - + } catch (InvalidValueException e) { logger.error(" ------ You SHOULD NOT SEE THIS MESSAGE. Error Creating a test Usage Record", e); throw new RuntimeException(e); } return usageRecord; - + } public final static String TEST_RESOUCE_OWNER = "resource.owner"; public final static String TEST_RESOUCE_SCOPE = TEST_SCOPE; - + public final static String TEST_RESOURCE_URI = "testprotocol://objectURI"; public final static String TEST_PROVIDER_URI = "testprotocol://providerURI"; - + private final static long MIN_DATA_VOLUME = 1024; private final static long MAX_DATA_VOLUME = 10240; @@ -118,18 +121,18 @@ public class TestUsageRecord { try { usageRecord.setConsumerId(TEST_CONSUMER_ID); usageRecord.setOperationResult(TEST_OPERATION_RESULT); - + usageRecord.setResourceOwner(TEST_RESOUCE_OWNER); usageRecord.setResourceScope(TEST_RESOUCE_SCOPE); - + usageRecord.setResourceURI(new URI(TEST_RESOURCE_URI)); usageRecord.setProviderURI(new URI(TEST_PROVIDER_URI)); - + usageRecord.setOperationType(AbstractStorageUsageRecord.OperationType.READ); usageRecord.setDataType(AbstractStorageUsageRecord.DataType.STORAGE); - + usageRecord.setDataVolume(generateRandomLong(MIN_DATA_VOLUME, MAX_DATA_VOLUME)); - + usageRecord.setQualifier("image/png"); @@ -138,103 +141,134 @@ public class TestUsageRecord { throw new RuntimeException(e); } return usageRecord; - + + } + + /** + * Create a valid #StorageVolumeUsageRecord with scope set automatically. + * @return the created #StorageVolumeUsageRecord + */ + public static StorageStatusRecord createTestStorageVolumeUsageRecord() { + StorageStatusRecord usageRecord = new StorageStatusRecord(); + try { + usageRecord.setConsumerId(TEST_CONSUMER_ID); + usageRecord.setOperationResult(TEST_OPERATION_RESULT); + usageRecord.setDataVolume(generateRandomLong(MIN_DATA_VOLUME, MAX_DATA_VOLUME)); + usageRecord.setDataType(AbstractStorageStatusRecord.DataType.STORAGE); + usageRecord.setDataCount(generateRandomLong(MIN_DATA_VOLUME, MAX_DATA_VOLUME)); + usageRecord.setDataServiceClass("dataServiceClass"); + usageRecord.setDataServiceName("dataServiceName"); + usageRecord.setDataServiceId("dataServiceId"); + usageRecord.setProviderId(new URI(TEST_PROVIDER_URI)); + + + + } catch (InvalidValueException | URISyntaxException e) { + logger.error(" ------ You SHOULD NOT SEE THIS MESSAGE. Error Creating a test Usage Record", e); + throw new RuntimeException(e); + } + return usageRecord; + } /** * @return */ public static JobUsageRecord createTestJobUsageRecord() { - + JobUsageRecord usageRecord = new JobUsageRecord(); try { usageRecord.setConsumerId(TEST_CONSUMER_ID); usageRecord.setOperationResult(TEST_OPERATION_RESULT); - + usageRecord.setJobId(TEST_JOB_ID); usageRecord.setJobName(TEST_JOB_NAME); Calendar startTime = Calendar.getInstance(); Calendar endTime = Calendar.getInstance(); endTime.setTimeInMillis(startTime.getTimeInMillis() + HALF_DURATION); startTime.setTimeInMillis(startTime.getTimeInMillis() - HALF_DURATION); - + usageRecord.setJobStartTime(startTime); usageRecord.setJobEndTime(endTime); - + } catch (InvalidValueException e) { logger.error(" ------ You SHOULD NOT SEE THIS MESSAGE. Error Creating a test Usage Record", e); } - + return usageRecord; } - + /** * @return */ public static TaskUsageRecord createTestTaskUsageRecord() { - + TaskUsageRecord usageRecord = new TaskUsageRecord(); try { usageRecord.setConsumerId(TEST_CONSUMER_ID); usageRecord.setOperationResult(TEST_OPERATION_RESULT); - + usageRecord.setTaskId(TEST_TASK_ID); usageRecord.setTaskId(TEST_JOB_ID); usageRecord.setHost(TEST_HOST); - + usageRecord.setRefHostingNodeId(UUID.randomUUID().toString()); - + Calendar startTime = Calendar.getInstance(); Calendar endTime = Calendar.getInstance(); endTime.setTimeInMillis(startTime.getTimeInMillis() + HALF_DURATION); startTime.setTimeInMillis(startTime.getTimeInMillis() - HALF_DURATION); - + usageRecord.setTaskStartTime(startTime); usageRecord.setTaskEndTime(endTime); - + HashMap inputParameters = new HashMap<>(); inputParameters.put(TEST_PROPERTY_NAME, TEST_PROPERTY_VALUE); inputParameters.put(TEST_PROPERTY_VALUE, TEST_PROPERTY_NAME); - + HashMap parameter = new HashMap<>(); parameter.put(TEST_PROPERTY_NAME, TEST_PROPERTY_VALUE); parameter.put(TEST_PROPERTY_VALUE, TEST_PROPERTY_NAME); - + inputParameters.put(TEST_NESTED_MAP, parameter); - + usageRecord.setInputParameters(inputParameters); - + } catch (InvalidValueException e) { logger.error(" ------ You SHOULD NOT SEE THIS MESSAGE. Error Creating a test Usage Record", e); } - + return usageRecord; } - - + + /** * @return */ public static PortletUsageRecord createTestPortletUsageRecord() { - + PortletUsageRecord usageRecord = new PortletUsageRecord(); try { usageRecord.setConsumerId(TEST_CONSUMER_ID); usageRecord.setOperationResult(TEST_OPERATION_RESULT); - + Calendar startTime = Calendar.getInstance(); Calendar endTime = Calendar.getInstance(); endTime.setTimeInMillis(startTime.getTimeInMillis() + HALF_DURATION); startTime.setTimeInMillis(startTime.getTimeInMillis() - HALF_DURATION); - + usageRecord.setPortletId(TEST_PORTLET_ID); usageRecord.setOperationId(TEST_PORTLET_OPERATION_ID); usageRecord.setMessage(TEST_PORTLET_MESSAGE); - + } catch (InvalidValueException e) { logger.error(" ------ You SHOULD NOT SEE THIS MESSAGE. Error Creating a test Usage Record", e); } - + return usageRecord; } + + + + }