From 50c8d4ac0e7bf43370b749ec1f1e65adbdc03247 Mon Sep 17 00:00:00 2001 From: Lucio Lelii Date: Wed, 1 Feb 2017 16:59:14 +0000 Subject: [PATCH] release 4.3 git-svn-id: http://svn.research-infrastructures.eu/public/d4science/gcube/branches/data-access/spd-plugin-fwk/3.1@142009 82a268e6-3cf1-43bd-a215-b396298e98cf --- .classpath | 10 ++ .project | 23 ++++ .settings/org.eclipse.core.resources.prefs | 7 + .settings/org.eclipse.jdt.core.prefs | 6 + .settings/org.eclipse.m2e.core.prefs | 5 + distro/INSTALL | 1 + distro/LICENSE | 6 + distro/MAINTAINERS | 2 + distro/README | 47 +++++++ distro/changelog.xml | 22 ++++ distro/descriptor.xml | 42 ++++++ distro/profile.xml | 29 +++++ distro/svnpath.txt | 0 pom.xml | 107 +++++++++++++++ .../data/spd/plugin/fwk/AbstractPlugin.java | 105 +++++++++++++++ .../org/gcube/data/spd/plugin/fwk/Labels.java | 30 +++++ .../gcube/data/spd/plugin/fwk/Searchable.java | 15 +++ .../ClassificationCapability.java | 60 +++++++++ .../fwk/capabilities/ExpansionCapability.java | 10 ++ .../fwk/capabilities/ImagesCapability.java | 11 ++ .../fwk/capabilities/MappingCapability.java | 17 +++ .../capabilities/OccurrencesCapability.java | 38 ++++++ .../fwk/capabilities/UnfoldCapability.java | 10 ++ .../fwk/readers/AbstractLocalReader.java | 45 +++++++ .../spd/plugin/fwk/readers/LocalReader.java | 48 +++++++ .../plugin/fwk/readers/OccurrencesReader.java | 19 +++ .../data/spd/plugin/fwk/readers/RSReader.java | 51 ++++++++ .../plugin/fwk/readers/ResultItemReader.java | 19 +++ .../spd/plugin/fwk/readers/StringReader.java | 16 +++ .../spd/plugin/fwk/util/ElementProperty.java | 46 +++++++ .../gcube/data/spd/plugin/fwk/util/Util.java | 122 ++++++++++++++++++ .../plugin/fwk/writers/AbstractWriter.java | 46 +++++++ .../plugin/fwk/writers/ClosableWriter.java | 8 ++ .../spd/plugin/fwk/writers/ObjectWriter.java | 17 +++ .../spd/plugin/fwk/writers/RecordWriter.java | 13 ++ .../writers/ResultElementWriterManager.java | 32 +++++ .../data/spd/plugin/fwk/writers/Writer.java | 79 ++++++++++++ .../spd/plugin/fwk/writers/WriterManager.java | 30 +++++ .../rswrapper/AbstractLocalWrapper.java | 36 ++++++ .../writers/rswrapper/AbstractWrapper.java | 42 ++++++ .../fwk/writers/rswrapper/LocalWrapper.java | 118 +++++++++++++++++ .../fwk/writers/rswrapper/ResultWrapper.java | 75 +++++++++++ .../gcube/data/spd/plugin/BindingTest.java | 49 +++++++ src/test/resources/log4j.properties | 18 +++ 44 files changed, 1532 insertions(+) create mode 100644 .classpath create mode 100644 .project create mode 100644 .settings/org.eclipse.core.resources.prefs create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 .settings/org.eclipse.m2e.core.prefs create mode 100644 distro/INSTALL create mode 100644 distro/LICENSE create mode 100644 distro/MAINTAINERS create mode 100644 distro/README create mode 100644 distro/changelog.xml create mode 100644 distro/descriptor.xml create mode 100644 distro/profile.xml create mode 100644 distro/svnpath.txt create mode 100644 pom.xml create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/AbstractPlugin.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/Labels.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/Searchable.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ClassificationCapability.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ExpansionCapability.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ImagesCapability.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/MappingCapability.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/OccurrencesCapability.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/UnfoldCapability.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/readers/AbstractLocalReader.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/readers/LocalReader.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/readers/OccurrencesReader.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/readers/RSReader.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/readers/ResultItemReader.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/readers/StringReader.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/util/ElementProperty.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/util/Util.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/AbstractWriter.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/ClosableWriter.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/ObjectWriter.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/RecordWriter.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/ResultElementWriterManager.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/Writer.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/WriterManager.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/AbstractLocalWrapper.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/AbstractWrapper.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/LocalWrapper.java create mode 100644 src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/ResultWrapper.java create mode 100644 src/test/java/org/gcube/data/spd/plugin/BindingTest.java create mode 100644 src/test/resources/log4j.properties diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..0f53f3e --- /dev/null +++ b/.classpath @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..69b9527 --- /dev/null +++ b/.project @@ -0,0 +1,23 @@ + + + spd-plugin-framework + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + + diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..d9b2aa7 --- /dev/null +++ b/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,7 @@ +#Fri Jul 06 17:13:26 CEST 2012 +eclipse.preferences.version=1 +encoding//src/main/java=UTF-8 +encoding//src/main/resources=UTF-8 +encoding//src/test/java=UTF-8 +encoding//src/test/resources=UTF-8 +encoding/=UTF-8 diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..b78be3a --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,6 @@ +#Fri Jul 06 17:13:26 CEST 2012 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.source=1.6 diff --git a/.settings/org.eclipse.m2e.core.prefs b/.settings/org.eclipse.m2e.core.prefs new file mode 100644 index 0000000..9cb7462 --- /dev/null +++ b/.settings/org.eclipse.m2e.core.prefs @@ -0,0 +1,5 @@ +#Fri Jul 06 17:04:03 CEST 2012 +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 diff --git a/distro/INSTALL b/distro/INSTALL new file mode 100644 index 0000000..ce0e21d --- /dev/null +++ b/distro/INSTALL @@ -0,0 +1 @@ +Used as a Library in the gCube Framework \ No newline at end of file diff --git a/distro/LICENSE b/distro/LICENSE new file mode 100644 index 0000000..630ba97 --- /dev/null +++ b/distro/LICENSE @@ -0,0 +1,6 @@ +gCube System - License +------------------------------------------------------------ + +The gCube/gCore software is licensed as Free Open Source software conveying to the EUPL (http://ec.europa.eu/idabc/eupl). +The software and documentation is provided by its authors/distributors "as is" and no expressed or +implied warranty is given for its use, quality or fitness for a particular case. diff --git a/distro/MAINTAINERS b/distro/MAINTAINERS new file mode 100644 index 0000000..84395c3 --- /dev/null +++ b/distro/MAINTAINERS @@ -0,0 +1,2 @@ +Lucio lelii (lucio.lelii@isti.cnr.it), CNR Pisa, +Istituto di Scienza e Tecnologie dell'Informazione "A. Faedo". diff --git a/distro/README b/distro/README new file mode 100644 index 0000000..c68a236 --- /dev/null +++ b/distro/README @@ -0,0 +1,47 @@ +The gCube System - spd client library + +------------------------------------------------------------ + +This work has been partially supported by the following European projects: DILIGENT (FP6-2003-IST-2), +D4Science (FP7-INFRA-2007-1.2.2), D4Science-II (FP7-INFRA-2008-1.2.2), iMarine (FP7-INFRASTRUCTURES-2011-2), +and EUBrazilOpenBio (FP7-ICT-2011-EU-Brazil). + + +Authors +------- + +* Lucio Lelii (lucio.lelii@isti.cnr.it), CNR Pisa, + Istituto di Scienza e Tecnologie dell'Informazione "A. Faedo". + + +Version and Release Date +------------------------ + +v. 1.0.0 (04-05-2012) + * First release + + +Description +----------- + + + + Download information +-------------------- + + + +Documentation +------------- + +Documentation is available on-line from the Projects Documentation Wiki: +https://gcube.wiki.gcube-system.org/gcube/index.php/Biodiversity_Access + + +Licensing +--------- + +This software is licensed under the terms you may find in the file named "LICENSE" in this directory. + + + diff --git a/distro/changelog.xml b/distro/changelog.xml new file mode 100644 index 0000000..6c711e1 --- /dev/null +++ b/distro/changelog.xml @@ -0,0 +1,22 @@ + + + species products discovery client library release + + + new calls added + + + a bug on the Writer has been fixed + + model part splitted in a different library + + + bug fixing + + + Unfold Capability for plugin added + + + gCore dependency removed + + \ No newline at end of file diff --git a/distro/descriptor.xml b/distro/descriptor.xml new file mode 100644 index 0000000..21d8c88 --- /dev/null +++ b/distro/descriptor.xml @@ -0,0 +1,42 @@ + + servicearchive + + tar.gz + + / + + + ${distroDirectory} + / + true + + README + LICENSE + INSTALL + MAINTAINERS + changelog.xml + + 755 + true + + + + + ${distroDirectory}/profile.xml + / + true + + + target/${build.finalName}.jar + /${artifactId} + + + ${distroDirectory}/svnpath.txt + /${artifactId} + true + + + \ No newline at end of file diff --git a/distro/profile.xml b/distro/profile.xml new file mode 100644 index 0000000..62d5fef --- /dev/null +++ b/distro/profile.xml @@ -0,0 +1,29 @@ + + + + Service + + ${description} + DataAccess + ${artifactId} + 1.0.0 + + + ${description} + ${artifactId} + ${version} + + ${groupId} + ${artifactId} + ${version} + + library + + ${build.finalName}.jar + + + + + + + diff --git a/distro/svnpath.txt b/distro/svnpath.txt new file mode 100644 index 0000000..e69de29 diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..33a8419 --- /dev/null +++ b/pom.xml @@ -0,0 +1,107 @@ + + 4.0.0 + + + org.gcube.tools + maven-parent + 1.0.0 + + + org.gcube.data.spd + spd-plugin-framework + 3.1.0-SNAPSHOT + spd-plugin-framework + SPD plugin framework + + + + + + org.gcube.resources + common-gcore-resources + [1.0.0-SNAPSHOT,2.0.0-SNAPSHOT) + + + + org.gcube.data.spd + spd-model + [3.0.0-SNAPSHOT,4.0.0-SNAPSHOT) + + + + org.gcube.execution + grs2library + [2.0.0-SNAPSHOT, 3.0.0-SNAPSHOT) + + + + org.gcube.data.access + streams + [2.0.0-SNAPSHOT, 3.0.0-SNAPSHOT) + + + + + + ${project.basedir}/distro + + + + + + maven-compiler-plugin + + 1.6 + 1.6 + + + + org.apache.maven.plugins + maven-resources-plugin + 2.5 + + + copy-profile + install + + copy-resources + + + target + + + ${distroDirectory} + true + + profile.xml + + + + + + + + + org.apache.maven.plugins + maven-assembly-plugin + 2.2 + + + ${distroDirectory}/descriptor.xml + + + + + servicearchive + install + + single + + + + + + + + \ No newline at end of file diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/AbstractPlugin.java b/src/main/java/org/gcube/data/spd/plugin/fwk/AbstractPlugin.java new file mode 100644 index 0000000..d8b23ff --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/AbstractPlugin.java @@ -0,0 +1,105 @@ +package org.gcube.data.spd.plugin.fwk; + +import java.util.Collections; +import java.util.Set; +import org.gcube.common.resources.gcore.ServiceEndpoint; +import org.gcube.data.spd.model.Conditions; +import org.gcube.data.spd.model.PropertySupport; +import org.gcube.data.spd.model.RepositoryInfo; +import org.gcube.data.spd.model.products.ResultItem; +import org.gcube.data.spd.model.util.Capabilities; +import org.gcube.data.spd.plugin.fwk.capabilities.ClassificationCapability; +import org.gcube.data.spd.plugin.fwk.capabilities.ExpansionCapability; +import org.gcube.data.spd.plugin.fwk.capabilities.MappingCapability; +import org.gcube.data.spd.plugin.fwk.capabilities.OccurrencesCapability; +import org.gcube.data.spd.plugin.fwk.capabilities.UnfoldCapability; + +public abstract class AbstractPlugin implements PropertySupport, Searchable{ + + private boolean initialized = false; + + private boolean useCache= false; + + public void initialize(ServiceEndpoint resource) throws Exception{ + initialized= true; + } + + public void update(ServiceEndpoint resource) throws Exception{} + + public void shutdown() throws Exception{} + + public ClassificationCapability getClassificationInterface(){return null;}; + + public MappingCapability getMappingInterface(){return null;}; + + public ExpansionCapability getExpansionInterface(){return null;}; + + public OccurrencesCapability getOccurrencesInterface(){return null;}; + + public UnfoldCapability getUnfoldInterface(){return null;}; + + public Set getSupportedProperties(){ + return Collections.emptySet(); + } + + public Set getSupportedCapabilities() { + return Collections.emptySet(); + } + + public abstract RepositoryInfo getRepositoryInfo(); + + @Override + public Class getHandledClass() { + return ResultItem.class; + } + + /* + @Override + public abstract void searchByScientificName(String word, + ObjectWriter writer, Condition... properties) throws ExternalRepositoryException; +*/ + public abstract String getRepositoryName(); + + public abstract String getDescription(); + + + public boolean isUseCache() { + return useCache; + } + + public void setUseCache(boolean useCache) { + this.useCache = useCache; + } + + public boolean isInitialized() { + return initialized; + } + + public boolean isRemote(){ + return false; + } + + + + @Override + public String toString() { + return getRepositoryName()+"(use-cache="+isUseCache()+")"; + } + + @Override + public boolean equals(Object obj) { + if (obj==null) return false; + AbstractPlugin ap = (AbstractPlugin) obj; + if (ap.getRepositoryName()==null || ap.getRepositoryName().equals("")) return false; + return ap.getRepositoryName().equals(this.getRepositoryName()); + } + + @Override + public int hashCode() { + return this.getRepositoryName().hashCode(); + } + + + +} + diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/Labels.java b/src/main/java/org/gcube/data/spd/plugin/fwk/Labels.java new file mode 100644 index 0000000..b8e598e --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/Labels.java @@ -0,0 +1,30 @@ +package org.gcube.data.spd.plugin.fwk; + +public class Labels { + + public static final String RANK_LABEL="rank"; + public static final String ACCORDINGTO_LABEL="accordingTo"; + public static final String SCIENTIFICNAME_LABEL="scientificName"; + public static final String COMMONNAME_LABEL="commonName"; + public static final String COMMONNAMES_LABEL="commonNames"; + public static final String PROVIDER_LABEL="provider"; + public static final String CITATION_LABEL="citation"; + public static final String PARENT_TAG="parent"; + + public static final String PRODUCTS_LABEL="products"; + + public static final String PRODUCT_LABEL="product"; + + public static final String TYPE_LABEL="type"; + public static final String KEY_LABEL="key"; + + public static final String DATASET_TAG="dataSet"; + public static final String DATAPROVIDER_TAG="dataProvider"; + public static final String NAME_TAG = "name"; + public static final String LANGUAGE_TAG = "language"; + public static final String COUNT_LABEL = "count"; + + public static final String CREDITS_LABEL = "credits"; + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/Searchable.java b/src/main/java/org/gcube/data/spd/plugin/fwk/Searchable.java new file mode 100644 index 0000000..4c51170 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/Searchable.java @@ -0,0 +1,15 @@ +package org.gcube.data.spd.plugin.fwk; + +import org.gcube.data.spd.model.Condition; +import org.gcube.data.spd.model.exceptions.ExternalRepositoryException; +import org.gcube.data.spd.model.products.ResultElement; +import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter; + + + +public interface Searchable{ + + public void searchByScientificName(String word, ObjectWriter writer, Condition ... properties) throws ExternalRepositoryException; + + public Class getHandledClass(); +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ClassificationCapability.java b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ClassificationCapability.java new file mode 100644 index 0000000..1b90fbf --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ClassificationCapability.java @@ -0,0 +1,60 @@ +package org.gcube.data.spd.plugin.fwk.capabilities; + +import java.util.Iterator; +import java.util.List; + +import org.gcube.data.spd.model.PropertySupport; +import org.gcube.data.spd.model.exceptions.ExternalRepositoryException; +import org.gcube.data.spd.model.exceptions.IdNotValidException; +import org.gcube.data.spd.model.exceptions.MethodNotSupportedException; +import org.gcube.data.spd.model.products.TaxonomyItem; +import org.gcube.data.spd.plugin.fwk.Searchable; +import org.gcube.data.spd.plugin.fwk.writers.ClosableWriter; +import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter; + + +public abstract class ClassificationCapability implements PropertySupport, Searchable{ + + /** + * retrieves all children giving a taxon id + * + * @param taxonId the taxon id + * @return a list of taxon + */ + public abstract List retrieveTaxonChildrenByTaxonId(String taxonId) throws IdNotValidException, ExternalRepositoryException; + + + /** + * retrieves taxon by ids + * + * @param ids the taxon ids + * @return a taxon + */ + public abstract void retrieveTaxonByIds(Iterator ids, ClosableWriter writer) throws ExternalRepositoryException; + + /** + * retrieves taxon by id + * + * @param taxonId the taxon id + * @return a taxon + */ + public abstract TaxonomyItem retrieveTaxonById(String id) throws IdNotValidException, ExternalRepositoryException; + + /** + * + * retrieve a list of synonyms + * + * @param writer + * @param ids + */ + public void getSynonymnsById(ObjectWriter writer, String id) throws IdNotValidException, MethodNotSupportedException, ExternalRepositoryException{ + throw new MethodNotSupportedException(); + } + + + @Override + public Class getHandledClass() { + return TaxonomyItem.class; + } + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ExpansionCapability.java b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ExpansionCapability.java new file mode 100644 index 0000000..b701988 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ExpansionCapability.java @@ -0,0 +1,10 @@ +package org.gcube.data.spd.plugin.fwk.capabilities; + +import org.gcube.data.spd.model.exceptions.ExternalRepositoryException; +import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter; + +public interface ExpansionCapability { + + public void getSynonyms(ObjectWriter writer, String scientifcName ) throws ExternalRepositoryException; + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ImagesCapability.java b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ImagesCapability.java new file mode 100644 index 0000000..d165057 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/ImagesCapability.java @@ -0,0 +1,11 @@ +package org.gcube.data.spd.plugin.fwk.capabilities; + + +import org.gcube.data.spd.model.products.Image; +import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter; + +public interface ImagesCapability { + + public void getImagesById(ObjectWriter writer, String ... ids) throws Exception; + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/MappingCapability.java b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/MappingCapability.java new file mode 100644 index 0000000..2cbf573 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/MappingCapability.java @@ -0,0 +1,17 @@ +package org.gcube.data.spd.plugin.fwk.capabilities; + +import org.gcube.data.spd.model.exceptions.ExternalRepositoryException; +import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter; + +public interface MappingCapability{ + + /** + * + * this method returns a set of scientific names related to the common name passed as input + * + * @param commonName to Map + * @return a set of scientificNames + * @throws Exception + */ + public void getRelatedScientificNames(ObjectWriter writer, String commonName) throws ExternalRepositoryException; +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/OccurrencesCapability.java b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/OccurrencesCapability.java new file mode 100644 index 0000000..481f6d9 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/OccurrencesCapability.java @@ -0,0 +1,38 @@ +package org.gcube.data.spd.plugin.fwk.capabilities; + +import java.util.Iterator; + +import org.gcube.data.spd.model.PropertySupport; +import org.gcube.data.spd.model.exceptions.ExternalRepositoryException; +import org.gcube.data.spd.model.products.OccurrencePoint; +import org.gcube.data.spd.plugin.fwk.Searchable; +import org.gcube.data.spd.plugin.fwk.writers.ClosableWriter; + +public abstract class OccurrencesCapability implements PropertySupport, Searchable{ + + /** + * retrieves all occurrences for the given ids + * + * @param writer the stream where the elements must be wrote + * @param keys a list of products keys + * @throws Exception + */ + public abstract void getOccurrencesByProductKeys(ClosableWriter writer, Iterator keys) throws ExternalRepositoryException; + + /** + * retrieves all occurrences for the given ids + * + * @param writer the stream where the elements must be wrote + * @param ids a list of occurrence ids + * @throws Exception + */ + public abstract void getOccurrencesByIds(ClosableWriter writer, Iterator ids) throws ExternalRepositoryException; + + @Override + public Class getHandledClass() { + return OccurrencePoint.class; + } + + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/UnfoldCapability.java b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/UnfoldCapability.java new file mode 100644 index 0000000..42a7ad5 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/capabilities/UnfoldCapability.java @@ -0,0 +1,10 @@ +package org.gcube.data.spd.plugin.fwk.capabilities; + +import org.gcube.data.spd.model.exceptions.ExternalRepositoryException; +import org.gcube.data.spd.plugin.fwk.writers.ObjectWriter; + +public interface UnfoldCapability { + + public void unfold(ObjectWriter writer, String scientificName) throws ExternalRepositoryException; + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/readers/AbstractLocalReader.java b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/AbstractLocalReader.java new file mode 100644 index 0000000..a0d2979 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/AbstractLocalReader.java @@ -0,0 +1,45 @@ +package org.gcube.data.spd.plugin.fwk.readers; + +import java.util.concurrent.BlockingQueue; + +import org.gcube.data.spd.plugin.fwk.writers.rswrapper.AbstractLocalWrapper; +import org.gcube.data.streams.Stream; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +public abstract class AbstractLocalReader implements Stream{ + + protected static final Logger logger = LoggerFactory.getLogger(AbstractLocalReader.class); + + protected BlockingQueue queue; + + protected T element = null; + + protected int timeoutInSeconds= 2; + + AbstractLocalWrapper wrapper ; + + public AbstractLocalReader(AbstractLocalWrapper wrapper) { + queue = wrapper.getQueue(); + this.wrapper = wrapper; + } + + + + public void setTimeoutInSeconds(int timeoutInSeconds) { + this.timeoutInSeconds = timeoutInSeconds; + } + + + + @Override + public T next() { + return element; + } + + @Override + public void remove() {} + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/readers/LocalReader.java b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/LocalReader.java new file mode 100644 index 0000000..15c9792 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/LocalReader.java @@ -0,0 +1,48 @@ +package org.gcube.data.spd.plugin.fwk.readers; + +import java.net.URI; +import java.util.concurrent.TimeUnit; + +import org.gcube.data.spd.plugin.fwk.writers.rswrapper.AbstractLocalWrapper; + +public class LocalReader extends AbstractLocalReader { + + public LocalReader(AbstractLocalWrapper wrapper) { + super(wrapper); + } + + @Override + public boolean hasNext() { + if (queue==null) return false; + else{ + try { + element=null; + while (!this.wrapper.isClosed() && element==null ) + element= queue.poll(timeoutInSeconds, TimeUnit.SECONDS); + if (element ==null) element=queue.poll(); + } catch (InterruptedException e) { + logger.warn("the queue is empty",e); + } + return element!=null; + } + } + + @Override + public URI locator() { + return null; + } + + @Override + public void close() { + logger.debug("closing reader"); + if (wrapper.isClosed()) + wrapper.disposeBuffer(); + else wrapper.close(); + } + + @Override + public boolean isClosed() { + return wrapper.isClosed(); + } + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/readers/OccurrencesReader.java b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/OccurrencesReader.java new file mode 100644 index 0000000..ca9e110 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/OccurrencesReader.java @@ -0,0 +1,19 @@ +package org.gcube.data.spd.plugin.fwk.readers; + +import org.gcube.data.spd.model.binding.Bindings; +import org.gcube.data.spd.model.products.OccurrencePoint; + + + +public class OccurrencesReader extends RSReader{ + + public OccurrencesReader(String locator) throws Exception { + super(locator); + } + + @Override + public OccurrencePoint transform(String serializedItem) throws Exception { + return Bindings.fromXml(serializedItem); + } + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/readers/RSReader.java b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/RSReader.java new file mode 100644 index 0000000..1bcb38d --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/RSReader.java @@ -0,0 +1,51 @@ +package org.gcube.data.spd.plugin.fwk.readers; + +import gr.uoa.di.madgik.grs.reader.ForwardReader; +import gr.uoa.di.madgik.grs.reader.GRS2ReaderException; +import gr.uoa.di.madgik.grs.record.GenericRecord; +import gr.uoa.di.madgik.grs.record.field.StringField; +import java.net.URI; +import java.util.Iterator; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class RSReader implements Iterator{ + + private static final Logger logger = LoggerFactory.getLogger(RSReader.class); + private Iterator it; + private ForwardReader reader; + + public RSReader(String locator) throws Exception{ + reader=new ForwardReader(new URI(locator)); + reader.setIteratorTimeout(3000); + it =reader.iterator(); + } + + @Override + public boolean hasNext() { + if (it.hasNext()) return true; + else { + try { + reader.close(); + } catch (GRS2ReaderException e) { + logger.error("error closing reader",e); + } + return false; + } + } + + @Override + public T next() { + try { + return transform(((StringField)it.next().getField("result")).getPayload()); + } catch (Exception e) { + logger.error("error getting tree",e); + return null; + } + } + + public abstract T transform(String serializedItem) throws Exception; + + @Override + public void remove() {} +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/readers/ResultItemReader.java b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/ResultItemReader.java new file mode 100644 index 0000000..ef694d7 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/ResultItemReader.java @@ -0,0 +1,19 @@ +package org.gcube.data.spd.plugin.fwk.readers; + +import org.gcube.data.spd.model.binding.Bindings; +import org.gcube.data.spd.model.products.ResultItem; + + + +public class ResultItemReader extends RSReader{ + + public ResultItemReader(String locator) throws Exception { + super(locator); + } + + @Override + public ResultItem transform(String serializedItem) throws Exception { + return Bindings.fromXml(serializedItem); + } + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/readers/StringReader.java b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/StringReader.java new file mode 100644 index 0000000..d421311 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/readers/StringReader.java @@ -0,0 +1,16 @@ +package org.gcube.data.spd.plugin.fwk.readers; + +public class StringReader extends RSReader{ + + public StringReader(String locator) throws Exception { + super(locator); + } + + @Override + public String transform(String serializedItem) throws Exception { + return serializedItem; + } + + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/util/ElementProperty.java b/src/main/java/org/gcube/data/spd/plugin/fwk/util/ElementProperty.java new file mode 100644 index 0000000..7073fdb --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/util/ElementProperty.java @@ -0,0 +1,46 @@ +package org.gcube.data.spd.plugin.fwk.util; + +import java.io.Serializable; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlRootElement; + + +@XmlRootElement +@XmlAccessorType(XmlAccessType.NONE) +public class ElementProperty implements Serializable{ + + + + /** + * + */ + private static final long serialVersionUID = 1L; + + + @XmlAttribute + private String name; + @XmlAttribute + private String value; + + protected ElementProperty() { + super(); + } + + public ElementProperty(String name, String value) { + super(); + this.name = name; + this.value = value; + } + + public String getName() { + return name; + } + + public String getValue() { + return value; + } + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/util/Util.java b/src/main/java/org/gcube/data/spd/plugin/fwk/util/Util.java new file mode 100644 index 0000000..3f06335 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/util/Util.java @@ -0,0 +1,122 @@ +package org.gcube.data.spd.plugin.fwk.util; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.util.Calendar; + +import javax.xml.bind.JAXBException; + +import org.gcube.data.spd.model.binding.Bindings; +import org.gcube.data.spd.model.exceptions.IdNotValidException; +import org.gcube.data.spd.model.products.OccurrencePoint; +import org.gcube.data.spd.model.products.ResultElement; +import org.gcube.data.spd.plugin.fwk.readers.OccurrencesReader; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class Util { + + private static final Logger logger = LoggerFactory.getLogger(Util.class); + + public static String keyEnrichment(String provider, String key){ + return provider+":"+key; + } + + public static String getProviderFromKey(String key) throws IdNotValidException{ + int index = key.indexOf(":"); + if (index==-1) throw new IdNotValidException(); + return key.substring(0, index); + } + + public static String getIdFromKey(String key) throws IdNotValidException { + int index = key.indexOf(":"); + if (index==-1) throw new IdNotValidException(); + return key.substring(index+1, key.length()); + } + + public static T copy(T obj) throws JAXBException { + return Bindings.fromXml(Bindings.toXml(obj)); + } + + public static File getDarwinCoreFile(OccurrencesReader reader) throws Exception{ + + DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); + + FileWriter writer = null; + + + try{ + File returnFile = File.createTempFile("darwinCore", "xml"); + writer = new FileWriter(returnFile); + + + writer.append(""); + writer.append(""); + + while (reader.hasNext()){ + + writer.append(""); + writer.append("en"); + + OccurrencePoint occurrence= reader.next(); + + if (occurrence.getModified() != null) + writer.append("" + df.format(occurrence.getModified().getTime()) + ""); + if (occurrence.getBasisOfRecord() != null) + writer.append("" + occurrence.getBasisOfRecord().name() + ""); + if (occurrence.getInstitutionCode() != null) + writer.append("" + occurrence.getInstitutionCode() + ""); + if (occurrence.getCollectionCode() != null) + writer.append("" + occurrence.getCollectionCode() + ""); + if (occurrence.getCatalogueNumber() != null) + writer.append("" + occurrence.getCatalogueNumber() + ""); + if (occurrence.getRecordedBy() != null) + writer.append("" + occurrence.getRecordedBy() + ""); + if (occurrence.getScientificName() != null) + writer.append("" + occurrence.getScientificName() + ""); + if (occurrence.getKingdom() != null) + writer.append("" + occurrence.getKingdom() + ""); + if (occurrence.getFamily() != null) + writer.append("" + occurrence.getFamily() + ""); + if (occurrence.getLocality() != null) + writer.append("" + occurrence.getLocality() + ""); + if (occurrence.getEventDate() != null) + { + writer.append("" + df.format(occurrence.getEventDate().getTime()) + ""); + writer.append("" + occurrence.getEventDate().get(Calendar.YEAR) + ""); + } + if (occurrence.getDecimalLatitude() != 0.0) + writer.append("" + occurrence.getDecimalLatitude() + ""); + if (occurrence.getDecimalLongitude() != 0.0) + writer.append("" + occurrence.getDecimalLongitude() + ""); + if (occurrence.getCoordinateUncertaintyInMeters() != null) + writer.append("" + occurrence.getCoordinateUncertaintyInMeters() + ""); + if (occurrence.getMaxDepth() != 0.0) + writer.append("" + occurrence.getMaxDepth() + ""); + if (occurrence.getMinDepth() != 0.0) + writer.append("" + occurrence.getMinDepth() + ""); + + writer.append(""); + } + + writer.append(""); + writer.flush(); + writer.close(); + return returnFile; + }catch (Exception e) { + logger.error("error writeing occurrences as darwin core",e); + throw e; + }finally{ + try { + writer.close(); + } catch (IOException e) { + logger.warn("error closing the output stream",e); + } + } + } + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/AbstractWriter.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/AbstractWriter.java new file mode 100644 index 0000000..01d666c --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/AbstractWriter.java @@ -0,0 +1,46 @@ +package org.gcube.data.spd.plugin.fwk.writers; + +import org.gcube.data.spd.plugin.fwk.writers.rswrapper.AbstractWrapper; + + + +public abstract class AbstractWriter implements ClosableWriter{ + + //private Logger logger= LoggerFactory.getLogger(AbstractWriter.class); + + protected boolean closed; + + private int links =0; + + private AbstractWrapper wrapper; + + protected int wrote; + + protected AbstractWriter(AbstractWrapper wrapper) { + this.wrapper = wrapper; + this.wrapper.register(); + } + + protected AbstractWrapper getWrapper() { + return wrapper; + } + + public synchronized void register(){ + links++; + } + + public synchronized void register(int links){ + this.links+=links; + } + + public synchronized void close() { + links--; + if (links<=0){ + if (!closed){ + if (!this.wrapper.isClosed())this.wrapper.unregister(); + closed=true; + } else throw new IllegalStateException("writer already closed"); + } + } + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ClosableWriter.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ClosableWriter.java new file mode 100644 index 0000000..16a06fc --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ClosableWriter.java @@ -0,0 +1,8 @@ +package org.gcube.data.spd.plugin.fwk.writers; + + +public interface ClosableWriter extends ObjectWriter { + + + public void close(); +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ObjectWriter.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ObjectWriter.java new file mode 100644 index 0000000..b8a8828 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ObjectWriter.java @@ -0,0 +1,17 @@ +package org.gcube.data.spd.plugin.fwk.writers; + +import org.gcube.data.spd.model.exceptions.StreamException; + + + + +public interface ObjectWriter { + + public boolean write(T t); + + public boolean write(StreamException error); + + public boolean isAlive(); + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/RecordWriter.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/RecordWriter.java new file mode 100644 index 0000000..14a31d6 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/RecordWriter.java @@ -0,0 +1,13 @@ +package org.gcube.data.spd.plugin.fwk.writers; + +public interface RecordWriter { + + boolean put(T element); + + boolean put(Exception error); + + void close(); + + boolean isClosed(); + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ResultElementWriterManager.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ResultElementWriterManager.java new file mode 100644 index 0000000..3aa3e2a --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/ResultElementWriterManager.java @@ -0,0 +1,32 @@ +package org.gcube.data.spd.plugin.fwk.writers; + +import org.gcube.data.spd.model.products.ResultElement; +import org.gcube.data.spd.plugin.fwk.util.Util; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class ResultElementWriterManager extends WriterManager { + + private static final Logger logger = LoggerFactory.getLogger(ResultElementWriterManager.class); + + protected String provider; + + public ResultElementWriterManager(String provider) { + super(); + this.provider = provider; + } + + @Override + public T enrich(T obj) { + try{ + return _enrich(Util.copy(obj)); + }catch (Exception e) { + logger.error("error enriching object",e); + return null; + } + } + + protected abstract T _enrich(T obj); + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/Writer.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/Writer.java new file mode 100644 index 0000000..e667eb9 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/Writer.java @@ -0,0 +1,79 @@ +package org.gcube.data.spd.plugin.fwk.writers; + + + +import org.gcube.data.spd.model.exceptions.InvalidRecordException; +import org.gcube.data.spd.model.exceptions.StreamBlockingException; +import org.gcube.data.spd.model.exceptions.StreamException; +import org.gcube.data.spd.model.exceptions.WrapperAlreadyDisposedException; +import org.gcube.data.spd.plugin.fwk.writers.rswrapper.AbstractWrapper; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +public class Writer extends AbstractWriter{ + + private static final Logger logger = LoggerFactory.getLogger(Writer.class); + + private WriterManager manager = new DefaultWriter(); + + + public Writer(AbstractWrapper wrapper) { + super(wrapper); + } + + public Writer(AbstractWrapper wrapper, WriterManager manager) { + super(wrapper); + this.manager = manager; + } + + public class DefaultWriter extends WriterManager{} + + + @Override + public synchronized boolean write(F t) { + if(this.getWrapper().isClosed()) return false; + if (manager.filter(t)){ + try{ + getWrapper().add(manager.enrich(t)); + }catch (InvalidRecordException e) { + logger.warn("error putting a result in the Writer",e); + return false; + }catch (WrapperAlreadyDisposedException e) { + logger.warn("wrapper already disposed",e); + return false; + } + } else{ + logger.debug("a result has been filtered"); + return false; + } + wrote++; + return true; + } + + @Override + public synchronized boolean write(StreamException error) { + try{ + getWrapper().add(error); + }catch (InvalidRecordException e) { + logger.warn("error putting execption in the Writer",e); + return false; + }catch (WrapperAlreadyDisposedException e) { + logger.warn("wrapper already disposed",e); + return false; + } + if (error instanceof StreamBlockingException ){ + getWrapper().close(); + return false; + } + return true; + } + + @Override + public boolean isAlive() { + return !getWrapper().isClosed(); + } + + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/WriterManager.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/WriterManager.java new file mode 100644 index 0000000..d71102c --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/WriterManager.java @@ -0,0 +1,30 @@ +package org.gcube.data.spd.plugin.fwk.writers; + +import org.gcube.data.streams.exceptions.StreamSkipSignal; +import org.gcube.data.streams.generators.Generator; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class WriterManager implements Generator { + + private static final Logger logger = LoggerFactory.getLogger(WriterManager.class); + + public T enrich(T obj){ return obj;} + + public boolean filter(T obj){return true;} + + @Override + public T yield(T element) { + try { + T enrichedElement = this.enrich(element); + if (enrichedElement==null) throw new Exception("error enriching element"); + return enrichedElement; + } catch (Exception e) { + logger.debug("skipping the result", e); + throw new StreamSkipSignal(); + } + } + + + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/AbstractLocalWrapper.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/AbstractLocalWrapper.java new file mode 100644 index 0000000..95a40c7 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/AbstractLocalWrapper.java @@ -0,0 +1,36 @@ +package org.gcube.data.spd.plugin.fwk.writers.rswrapper; + +import java.util.UUID; +import java.util.concurrent.BlockingQueue; + + +public abstract class AbstractLocalWrapper extends AbstractWrapper { + + private String locator; + protected boolean closed = false; + + public AbstractLocalWrapper() { + super(); + this.locator = UUID.randomUUID().toString(); + } + + public AbstractLocalWrapper(int queueSize) { + super(); + this.locator = UUID.randomUUID().toString(); + } + + public abstract BlockingQueue getQueue(); + + @Override + public String getLocator() { + return this.locator; + } + + @Override + public boolean isClosed() { + return closed; + } + + public abstract void disposeBuffer(); + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/AbstractWrapper.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/AbstractWrapper.java new file mode 100644 index 0000000..5275b4f --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/AbstractWrapper.java @@ -0,0 +1,42 @@ +package org.gcube.data.spd.plugin.fwk.writers.rswrapper; + +import org.gcube.data.spd.model.exceptions.InvalidRecordException; +import org.gcube.data.spd.model.exceptions.StreamException; +import org.gcube.data.spd.model.exceptions.WrapperAlreadyDisposedException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class AbstractWrapper { + + Logger logger= LoggerFactory.getLogger(AbstractWrapper.class); + + protected int links; + + public abstract String getLocator(); + + public abstract boolean add(T result) throws InvalidRecordException, WrapperAlreadyDisposedException; + + public abstract boolean add(StreamException result) throws InvalidRecordException, WrapperAlreadyDisposedException; + + public abstract void close(); + + public synchronized void unregister(){ + logger.info(Thread.currentThread().getId()+" - closing wrapper"); + links--; + if (links<=0){ + if (!this.isClosed()){ + this.close(); + } + else throw new IllegalStateException("wrapper already closed"); + } + } + + + + public synchronized void register(){ + this.links++; + } + + public abstract boolean isClosed(); + +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/LocalWrapper.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/LocalWrapper.java new file mode 100644 index 0000000..6ea8553 --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/LocalWrapper.java @@ -0,0 +1,118 @@ +package org.gcube.data.spd.plugin.fwk.writers.rswrapper; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.TimeUnit; + +import org.gcube.data.spd.model.exceptions.InvalidRecordException; +import org.gcube.data.spd.model.exceptions.StreamException; +import org.gcube.data.spd.model.exceptions.WrapperAlreadyDisposedException; + +import java.util.Collections; + + +public class LocalWrapper extends AbstractLocalWrapper { + + private static Map> wrapperLocatorMap = new HashMap>(); + + public static LocalWrapper getWrapper(String locator){ + return wrapperLocatorMap.get(locator); + } + + private String locator; + + private ArrayBlockingQueue queue; + + private List errorList = new ArrayList(); + + private boolean forceOpen = false; + + private int timeoutTimeInMinutes =1; + + public LocalWrapper() { + super(); + this.locator = UUID.randomUUID().toString(); + this.queue = new ArrayBlockingQueue(100); + } + + public LocalWrapper(int queueSize) { + super(); + this.locator = UUID.randomUUID().toString(); + this.queue = new ArrayBlockingQueue(queueSize); + } + + + @Override + public String getLocator() { + return this.locator; + } + + @Override + public synchronized boolean add(T input) throws InvalidRecordException, WrapperAlreadyDisposedException { + if (this.closed) new WrapperAlreadyDisposedException("the local wrapper has been disposed"); + try{ + return this.queue.offer(input, timeoutTimeInMinutes,TimeUnit.MINUTES); + }catch (InterruptedException e) { + this.close(); + this.queue= null; + throw new WrapperAlreadyDisposedException("the local wrapper has been disposed"); + } + } + + @Override + public void close(){ + if (!isForceOpen()){ + this.closed= true; + } + else logger.warn("cannot close the Wrapper, forceOpen enabled"); + } + + @Override + public ArrayBlockingQueue getQueue(){ + return queue; + } + + + + public void setTimeoutTimeInMinutes(int timeoutTimeInMinutes) { + this.timeoutTimeInMinutes = timeoutTimeInMinutes; + } + + + public boolean isForceOpen() { + return forceOpen; + } + + public void forceOpen() { + this.forceOpen = true; + } + + public void disableForceOpen() { + this.forceOpen = false; + } + + public void disableForceOpenAndClose() { + this.forceOpen = false; + this.close(); + } + + @Override + public void disposeBuffer() { + queue = null; + } + + @Override + public boolean add(StreamException result) throws InvalidRecordException, + WrapperAlreadyDisposedException { + errorList.add(result); + return true; + } + + public List getErrors(){ + return Collections.unmodifiableList(this.errorList); + } +} diff --git a/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/ResultWrapper.java b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/ResultWrapper.java new file mode 100644 index 0000000..2d62d4c --- /dev/null +++ b/src/main/java/org/gcube/data/spd/plugin/fwk/writers/rswrapper/ResultWrapper.java @@ -0,0 +1,75 @@ +package org.gcube.data.spd.plugin.fwk.writers.rswrapper; + +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +import org.gcube.data.spd.model.exceptions.InvalidRecordException; +import org.gcube.data.spd.model.exceptions.StreamException; +import org.gcube.data.spd.model.exceptions.WrapperAlreadyDisposedException; +import org.gcube.data.spd.plugin.fwk.writers.RecordWriter; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +public class ResultWrapper extends AbstractWrapper{ + + + private static final Logger logger = LoggerFactory.getLogger(ResultWrapper.class); + + private static Map> wrapperLocatorMap = new HashMap>(); + + public static ResultWrapper getWrapper(String locator){ + return wrapperLocatorMap.get(locator); + } + + private String locator; + + private RecordWriter writer=null; + + + public ResultWrapper(RecordWriter rw) { + this.writer = rw; + this.locator = UUID.randomUUID().toString(); + } + + + + public synchronized boolean add(T input) throws InvalidRecordException, WrapperAlreadyDisposedException{ + + try { + return writer.put(input); + }catch (Exception e) { + logger.trace("the writer is already disposed (trying to write something when it is closed)"); + throw new WrapperAlreadyDisposedException(e); + } + } + + + public void close(){ + this.writer.close(); + } + + + @Override + public boolean isClosed() { + return this.writer.isClosed(); + } + + @Override + public boolean add(StreamException result) throws InvalidRecordException, + WrapperAlreadyDisposedException { + try { + return writer.put(result); + }catch (Exception e) { + logger.trace("the writer is already disposed (trying to write something when it is closed)"); + throw new WrapperAlreadyDisposedException(e); + } + } + + @Override + public String getLocator() { + return this.locator; + } + +} diff --git a/src/test/java/org/gcube/data/spd/plugin/BindingTest.java b/src/test/java/org/gcube/data/spd/plugin/BindingTest.java new file mode 100644 index 0000000..b96c6db --- /dev/null +++ b/src/test/java/org/gcube/data/spd/plugin/BindingTest.java @@ -0,0 +1,49 @@ +package org.gcube.data.spd.plugin; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import org.gcube.data.spd.model.KeyValue; +import org.gcube.data.spd.model.PointInfo; +import org.gcube.data.spd.model.binding.Bindings; +import org.gcube.data.spd.model.products.OccurrencePoint; + + +public class BindingTest { + + public static void main(String[] args) throws Exception{ + occurrenceTest(); + } + + static private String occurrencePoint = "Canadian Museum of Nature - Fish CollectionCanadian Museum of Nature - Fish Collection (OBIS Canada)Ocean Biogeographic Information System"; + + public static void pointInfoTest() throws Exception{ + PointInfo pi= new PointInfo(12.3, 15.5); + + List keyvaluelist= new ArrayList(); + keyvaluelist.add(new KeyValue("test", "value")); + + + //System.out.println(Arrays.toString(pi.getPropertiesList().toArray(new KeyValue[0]))); + + pi.setPropertiesList(keyvaluelist); + System.out.println(Arrays.toString(pi.getPropertiesList().toArray(new KeyValue[0]))); + + String xml =Bindings.toXml(pi); + System.out.println(xml); + + PointInfo resPi = Bindings.fromXml(xml); + + System.out.println(Arrays.toString(pi.getPropertiesList().toArray(new KeyValue[0]))); + } + + + + public static void occurrenceTest() throws Exception{ + OccurrencePoint point = (OccurrencePoint)Bindings.fromXml(occurrencePoint); + + System.out.println(Bindings.toXml(point)); + + } + +} diff --git a/src/test/resources/log4j.properties b/src/test/resources/log4j.properties new file mode 100644 index 0000000..bf90004 --- /dev/null +++ b/src/test/resources/log4j.properties @@ -0,0 +1,18 @@ +# Set root category priority to WARN and its only appender to A1. +log4j.rootCategory=TRACE, A1 + +log4j.appender.A1=org.apache.log4j.ConsoleAppender + +# A2 uses PatternLayout. +log4j.appender.A1.layout=org.apache.log4j.PatternLayout +log4j.appender.A1.layout.ConversionPattern=[CodelistManager] %d{HH:mm:ss,SSS} %-5p %c{2} [%t,%M:%L] %m%n + + + +# Display any warnings generated by our code + +log4j.category.org.gcube.data.spd=TRACE,A1 +log4j.category.org.gcube=INFO, A1 +log4j.additivity.org.gcube.data.spd=false + +