308 lines
11 KiB
Java
308 lines
11 KiB
Java
/**
|
|
*
|
|
*/
|
|
package org.gcube.accounting.persistence;
|
|
|
|
import java.io.StringWriter;
|
|
import java.net.URL;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
|
|
import org.gcube.common.resources.gcore.Resource;
|
|
import org.gcube.common.resources.gcore.Resources;
|
|
import org.gcube.common.resources.gcore.ServiceEndpoint;
|
|
import org.gcube.common.resources.gcore.ServiceEndpoint.AccessPoint;
|
|
import org.gcube.common.resources.gcore.ServiceEndpoint.Profile;
|
|
import org.gcube.common.resources.gcore.ServiceEndpoint.Property;
|
|
import org.gcube.common.resources.gcore.ServiceEndpoint.Runtime;
|
|
import org.gcube.common.resources.gcore.common.Platform;
|
|
import org.gcube.common.resources.gcore.utils.Group;
|
|
import org.gcube.common.scope.api.ScopeProvider;
|
|
import org.gcube.informationsystem.publisher.AdvancedScopedPublisher;
|
|
import org.gcube.informationsystem.publisher.RegistryPublisherFactory;
|
|
import org.gcube.informationsystem.publisher.ScopedPublisher;
|
|
import org.gcube.informationsystem.publisher.exception.RegistryNotFoundException;
|
|
import org.gcube.resources.discovery.client.api.DiscoveryClient;
|
|
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
|
|
import org.gcube.resources.discovery.icclient.ICFactory;
|
|
import org.junit.Assert;
|
|
import org.junit.Test;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
/**
|
|
* @author Luca Frosini (ISTI - CNR) http://www.lucafrosini.com/
|
|
*
|
|
*/
|
|
public class AccountingPersistenceConfigurationTest {
|
|
|
|
private static final Logger logger = LoggerFactory.getLogger(AccountingPersistenceConfigurationTest.class);
|
|
|
|
public static final String PROFILE_DESCRIPTION = "This ServiceEndpoint contains the parameter to connect to DB to persist log accounting.";
|
|
public static final String RUNNING_ON = "http://localhost:5984";
|
|
|
|
public static final String LOAD_BALANCER = "loadBalancer";
|
|
|
|
public static final String READY = "READY";
|
|
|
|
public static final String TEST_VERSION = "1.0.0";
|
|
public static final short[] VERSION_SLICES = new short[]{1,6,0,0};
|
|
|
|
public static final String DESCRIPTION = "CouchDB Server";
|
|
public static final String COUCHDB_CLASS_NAME = "AccountingPersistenceCouchDB";
|
|
|
|
public static final String FAKE_USERNAME = "fakeusername";
|
|
public static final String FAKE_PASSWORD = "fakepassword";
|
|
|
|
public static final String[] SCOPES = new String[]{"/gcube", "/gcube/devNext", "/gcube/devsec"};
|
|
public static final String GCUBE_SCOPE = SCOPES[0];
|
|
public static final String GCUBE_DEVNEXT_SCOPE = SCOPES[1];
|
|
|
|
public static final String DB_NAME_PROPERTY_NAME = "dbName";
|
|
public static final String DB_NAME_PROPERTY_VALUE = "accounting";
|
|
|
|
|
|
public static final String[] ALL_SCOPES = new String[]{
|
|
"/gcube",
|
|
"/gcube/devsec",
|
|
"/gcube/devsec/devVRE",
|
|
"/gcube/devsec/VALEN-TINA",
|
|
"/gcube/devsec/USTORE_VRE",
|
|
"/gcube/devNext",
|
|
"/gcube/devNext/NextNext"
|
|
};
|
|
|
|
|
|
/**
|
|
* Publish the provided resource on all Service Scopes retrieved from
|
|
* Context
|
|
* @param resource to be published
|
|
* @throws RegistryNotFoundException if the Registry is not found so the
|
|
* resource has not be published
|
|
*/
|
|
private static void publishScopedResource(Resource resource, List<String> scopes) throws Exception {
|
|
StringWriter stringWriter = new StringWriter();
|
|
Resources.marshal(resource, stringWriter);
|
|
|
|
ScopedPublisher scopedPublisher = RegistryPublisherFactory.scopedPublisher();
|
|
try {
|
|
logger.debug("Trying to publish to {}:\n{}", scopes, stringWriter);
|
|
scopedPublisher.create(resource, scopes);
|
|
} catch (Exception e) {
|
|
logger.error("The resource was not published", e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove the resource from IS
|
|
* @param resource to be unpublished
|
|
* @throws RegistryNotFoundException if the Registry is not found so the
|
|
* resource has not be published
|
|
*/
|
|
private static void unPublishScopedResource(Resource resource) throws RegistryNotFoundException, Exception {
|
|
//StringWriter stringWriter = new StringWriter();
|
|
//Resources.marshal(resource, stringWriter);
|
|
|
|
ScopedPublisher scopedPublisher = RegistryPublisherFactory.scopedPublisher();
|
|
AdvancedScopedPublisher advancedScopedPublisher = new AdvancedScopedPublisher(scopedPublisher);
|
|
|
|
String id = resource.id();
|
|
logger.debug("Trying to remove {} with ID {} from {}", resource.getClass().getSimpleName(), id, ScopeProvider.instance.get());
|
|
|
|
//scopedPublisher.remove(resource, scopes);
|
|
advancedScopedPublisher.forceRemove(resource);
|
|
|
|
logger.debug("{} with ID {} removed successfully", resource.getClass().getSimpleName(), id);
|
|
}
|
|
|
|
/**
|
|
* Create the Service Endpoint using information related to discovered
|
|
* available plugins and their own discovered capabilities
|
|
* @return the created {@link ServiceEndpoint}
|
|
*/
|
|
protected static ServiceEndpoint createServiceEndpoint(){
|
|
logger.debug("Getting Available Plugins and their own supported capabilities");
|
|
|
|
logger.debug("Creating ServiceEndpoint to publish on IS available plugins and their own supported capabilities");
|
|
ServiceEndpoint serviceEndpoint = new ServiceEndpoint();
|
|
Profile profile = serviceEndpoint.newProfile();
|
|
AccountingPersistenceConfiguration accountingPersistenceConfiguration = new AccountingPersistenceConfiguration();
|
|
profile.category(accountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY);
|
|
profile.name(accountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME);
|
|
profile.version(TEST_VERSION);
|
|
profile.description(PROFILE_DESCRIPTION);
|
|
|
|
|
|
Platform platform = profile.newPlatform();
|
|
platform.name(RUNNING_ON);
|
|
|
|
platform.version(VERSION_SLICES[0]);
|
|
platform.minorVersion(VERSION_SLICES[1]);
|
|
platform.buildVersion(VERSION_SLICES[2]);
|
|
platform.revisionVersion(VERSION_SLICES[3]);
|
|
|
|
Runtime runtime = profile.newRuntime();
|
|
runtime.hostedOn(RUNNING_ON);
|
|
runtime.status(READY);
|
|
|
|
Group<AccessPoint> accessPoints = profile.accessPoints();
|
|
|
|
AccessPoint accessPointElement = new AccessPoint();
|
|
accessPoints.add(accessPointElement);
|
|
accessPointElement.description(DESCRIPTION);
|
|
accessPointElement.credentials(FAKE_USERNAME, FAKE_PASSWORD);
|
|
|
|
accessPointElement.address(RUNNING_ON);
|
|
accessPointElement.name(LOAD_BALANCER);
|
|
|
|
Group<Property> properties = accessPointElement.properties();
|
|
|
|
Property className = new Property();
|
|
className.nameAndValue(AccountingPersistenceConfiguration.PERSISTENCE_CLASS_NAME, COUCHDB_CLASS_NAME);
|
|
properties.add(className);
|
|
|
|
Property dbName = new Property();
|
|
dbName.nameAndValue(DB_NAME_PROPERTY_NAME, DB_NAME_PROPERTY_VALUE);
|
|
properties.add(dbName);
|
|
|
|
StringWriter stringWriter = new StringWriter();
|
|
Resources.marshal(serviceEndpoint, stringWriter);
|
|
logger.debug("The created ServiceEndpoint profile is\n{}", stringWriter.toString());
|
|
|
|
return serviceEndpoint;
|
|
}
|
|
|
|
protected void clean(){
|
|
ScopeProvider.instance.set(GCUBE_DEVNEXT_SCOPE);
|
|
|
|
AccountingPersistenceConfiguration accountingPersistenceConfiguration = new AccountingPersistenceConfiguration();
|
|
|
|
SimpleQuery query = ICFactory.queryFor(ServiceEndpoint.class)
|
|
.addCondition(String.format("$resource/Profile/Category/text() eq '%s'", accountingPersistenceConfiguration.SERVICE_ENDPOINT_CATEGORY))
|
|
.addCondition(String.format("$resource/Profile/Name/text() eq '%s'", accountingPersistenceConfiguration.SERVICE_ENDPOINT_NAME))
|
|
.addCondition(String.format("$resource/Profile/RunTime/HostedOn/text() eq '%s'", RUNNING_ON))
|
|
.setResult("$resource");
|
|
|
|
DiscoveryClient<ServiceEndpoint> client = ICFactory.clientFor(ServiceEndpoint.class);
|
|
List<ServiceEndpoint> serviceEndpoints = client.submit(query);
|
|
|
|
for (ServiceEndpoint serviceEndpoint : serviceEndpoints) {
|
|
try {
|
|
logger.debug("Trying to unpublish the old ServiceEndpoint with ID {} from scope {}",
|
|
serviceEndpoint.id(), GCUBE_DEVNEXT_SCOPE);
|
|
unPublishScopedResource(serviceEndpoint);
|
|
} catch(Exception e){
|
|
logger.debug("Exception trying to unpublish the old ServiceEndpoint with ID {} from scope {}",
|
|
serviceEndpoint.id(), GCUBE_DEVNEXT_SCOPE, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testPersistenceConfigurationFromIS() throws Exception{
|
|
ScopeProvider.instance.set(GCUBE_DEVNEXT_SCOPE);
|
|
boolean createResource = false;
|
|
ServiceEndpoint serviceEndpoint = null;
|
|
if(createResource){
|
|
List<String> scopes = Arrays.asList(SCOPES);
|
|
serviceEndpoint = createServiceEndpoint();
|
|
publishScopedResource(serviceEndpoint, scopes);
|
|
}
|
|
|
|
try {
|
|
AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(COUCHDB_CLASS_NAME);
|
|
if(createResource){
|
|
Assert.assertTrue(persitenceConfiguration.getUri().toURL().equals(new URL(RUNNING_ON)));
|
|
Assert.assertTrue(persitenceConfiguration.getUsername().compareTo(FAKE_USERNAME)==0);
|
|
Assert.assertTrue(persitenceConfiguration.getPassword().compareTo(FAKE_PASSWORD)==0);
|
|
Assert.assertTrue(persitenceConfiguration.getProperty(DB_NAME_PROPERTY_NAME).compareTo(DB_NAME_PROPERTY_VALUE)==0);
|
|
}
|
|
} finally {
|
|
if(createResource){
|
|
unPublishScopedResource(serviceEndpoint);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testPersistenceConfigurationFromISInDifferentScopes() throws Exception{
|
|
for(String scope : ALL_SCOPES){
|
|
logger.debug("START ======================================================");
|
|
ScopeProvider.instance.set(scope);
|
|
try {
|
|
AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(COUCHDB_CLASS_NAME);
|
|
logger.debug("{} : {}", AccountingPersistenceConfiguration.class.getSimpleName(), persitenceConfiguration);
|
|
}catch(IndexOutOfBoundsException e){
|
|
logger.debug("No AccountingPersistenceConfiguration : \n {} {} \n\n", e.getClass().getName(), e.getMessage());
|
|
} catch(Exception e){
|
|
logger.error("Error getting AccountingPersistenceConfiguration", e);
|
|
throw e;
|
|
}
|
|
logger.debug(" END ======================================================");
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void getUsernamePasswordForScopes() throws Exception{
|
|
for(String scope : SCOPES){
|
|
ScopeProvider.instance.set(scope);
|
|
try {
|
|
AccountingPersistenceConfiguration persitenceConfiguration = new AccountingPersistenceConfiguration(COUCHDB_CLASS_NAME);
|
|
logger.debug("{} {} - {} : {}", scope,
|
|
persitenceConfiguration.getUri(),
|
|
persitenceConfiguration.getUsername(),
|
|
persitenceConfiguration.getPassword());
|
|
}catch(IndexOutOfBoundsException e){
|
|
logger.debug("No AccountingPersistenceConfiguration : \n {} {} \n\n", e.getClass().getName(), e.getMessage());
|
|
} catch(Exception e){
|
|
logger.error("Error getting AccountingPersistenceConfiguration", e);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
@Test
|
|
public void testFiles() throws IOException{
|
|
File file = new File("./aux.txt");
|
|
logger.debug("file : {}", file.getAbsolutePath());
|
|
|
|
String aux = "AUX";
|
|
try(FileWriter fw = new FileWriter(file, true);
|
|
BufferedWriter bw = new BufferedWriter(fw);
|
|
PrintWriter out = new PrintWriter(bw)){
|
|
out.println(aux);
|
|
out.flush();
|
|
} catch( IOException e ){
|
|
throw e;
|
|
}
|
|
|
|
|
|
File same = file;
|
|
logger.debug("same : {}", same.getAbsolutePath());
|
|
boolean moved = same.renameTo(new File(file.getAbsolutePath()+".RENAMED"));
|
|
logger.debug("Moved : {}", moved);
|
|
|
|
logger.debug("AFTER RENAME");
|
|
logger.debug("file : {}", file.getAbsolutePath());
|
|
logger.debug("same : {}", same.getAbsolutePath());
|
|
|
|
|
|
aux = "DONE";
|
|
try(FileWriter fw = new FileWriter(file, true);
|
|
BufferedWriter bw = new BufferedWriter(fw);
|
|
PrintWriter out = new PrintWriter(bw)){
|
|
out.println(aux);
|
|
out.flush();
|
|
} catch( IOException e ){
|
|
throw e;
|
|
}
|
|
|
|
}
|
|
*/
|
|
|
|
}
|