implementation of the oozie wf to prepare the openorgs input: relations between organizations

dhp-workflows/dhp-dedup-openaire/src/main/java/eu/dnetlib/dhp/oa/dedup/OrgSimRel.java

@@ -0,0 +1,83 @@
+package eu.dnetlib.dhp.oa.dedup;
+
+import java.io.Serializable;
+
+public class OrgSimRel implements Serializable {
+
+    String local_id;
+    String oa_original_id;
+    String oa_name;
+    String oa_acronym;
+    String oa_country;
+    String oa_url;
+    String oa_collectedfrom;
+
+    public OrgSimRel() {
+    }
+
+    public OrgSimRel(String local_id, String oa_original_id, String oa_name, String oa_acronym, String oa_country, String oa_url, String oa_collectedfrom) {
+        this.local_id = local_id;
+        this.oa_original_id = oa_original_id;
+        this.oa_name = oa_name;
+        this.oa_acronym = oa_acronym;
+        this.oa_country = oa_country;
+        this.oa_url = oa_url;
+        this.oa_collectedfrom = oa_collectedfrom;
+    }
+
+    public String getLocal_id() {
+        return local_id;
+    }
+
+    public void setLocal_id(String local_id) {
+        this.local_id = local_id;
+    }
+
+    public String getOa_original_id() {
+        return oa_original_id;
+    }
+
+    public void setOa_original_id(String oa_original_id) {
+        this.oa_original_id = oa_original_id;
+    }
+
+    public String getOa_name() {
+        return oa_name;
+    }
+
+    public void setOa_name(String oa_name) {
+        this.oa_name = oa_name;
+    }
+
+    public String getOa_acronym() {
+        return oa_acronym;
+    }
+
+    public void setOa_acronym(String oa_acronym) {
+        this.oa_acronym = oa_acronym;
+    }
+
+    public String getOa_country() {
+        return oa_country;
+    }
+
+    public void setOa_country(String oa_country) {
+        this.oa_country = oa_country;
+    }
+
+    public String getOa_url() {
+        return oa_url;
+    }
+
+    public void setOa_url(String oa_url) {
+        this.oa_url = oa_url;
+    }
+
+    public String getOa_collectedfrom() {
+        return oa_collectedfrom;
+    }
+
+    public void setOa_collectedfrom(String oa_collectedfrom) {
+        this.oa_collectedfrom = oa_collectedfrom;
+    }
+}

dhp-workflows/dhp-dedup-openaire/src/main/java/eu/dnetlib/dhp/oa/dedup/SparkCollectSimRels.java

@@ -4,16 +4,20 @@ import eu.dnetlib.dhp.application.ArgumentApplicationParser;
 import eu.dnetlib.dhp.schema.oaf.DataInfo;
 import eu.dnetlib.dhp.schema.oaf.Relation;
 import eu.dnetlib.dhp.utils.ISLookupClientFactory;
+import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;
 import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
+import eu.dnetlib.pace.config.DedupConfig;
 import org.apache.commons.io.IOUtils;
 import org.apache.spark.SparkConf;
 import org.apache.spark.api.java.JavaPairRDD;
 import org.apache.spark.api.java.JavaRDD;
 import org.apache.spark.sql.*;
+import org.dom4j.DocumentException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import scala.Tuple2;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -65,7 +69,7 @@ public class SparkCollectSimRels extends AbstractSparkAction {
     }
 
     @Override
-    void run(ISLookUpService isLookUpService) {
+    void run(ISLookUpService isLookUpService) throws DocumentException, ISLookUpException, IOException {
 
         // read oozie parameters
         final String isLookUpUrl = parser.get("isLookUpUrl");
@@ -126,11 +130,16 @@ public class SparkCollectSimRels extends AbstractSparkAction {
                 Encoders.bean(Relation.class)
         ).repartition(numPartitions);
 
-        savePostgresRelation(organizationRelations, workingPath, actionSetId, "organization");
-        savePostgresRelation(resultRelations, workingPath, actionSetId, "publication");
-        savePostgresRelation(resultRelations, workingPath, actionSetId, "software");
-        savePostgresRelation(resultRelations, workingPath, actionSetId, "otherresearchproduct");
-        savePostgresRelation(resultRelations, workingPath, actionSetId, "dataset");
+        for (DedupConfig dedupConf : getConfigurations(isLookUpService, actionSetId)) {
+            switch(dedupConf.getWf().getSubEntityValue()){
+                case "organization":
+                    savePostgresRelation(organizationRelations, workingPath, actionSetId, "organization");
+                    break;
+                default:
+                    savePostgresRelation(resultRelations, workingPath, actionSetId, dedupConf.getWf().getSubEntityValue());
+                    break;
+            }
+        }
 
     }
 

dhp-workflows/dhp-dedup-openaire/src/main/java/eu/dnetlib/dhp/oa/dedup/SparkPrepareOrgRels.java

@@ -0,0 +1,168 @@
+package eu.dnetlib.dhp.oa.dedup;
+
+import eu.dnetlib.dhp.application.ArgumentApplicationParser;
+import eu.dnetlib.dhp.schema.common.EntityType;
+import eu.dnetlib.dhp.schema.common.ModelSupport;
+import eu.dnetlib.dhp.schema.oaf.*;
+import eu.dnetlib.dhp.utils.ISLookupClientFactory;
+import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;
+import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
+import eu.dnetlib.pace.config.DedupConfig;
+import org.apache.commons.io.IOUtils;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.spark.SparkConf;
+import org.apache.spark.api.java.JavaRDD;
+import org.apache.spark.api.java.function.MapFunction;
+import org.apache.spark.api.java.function.MapGroupsFunction;
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.Encoders;
+import org.apache.spark.sql.SaveMode;
+import org.apache.spark.sql.SparkSession;
+import org.dom4j.DocumentException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import scala.Tuple2;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+
+public class SparkPrepareOrgRels extends AbstractSparkAction {
+
+    private static final Logger log = LoggerFactory.getLogger(SparkCreateDedupRecord.class);
+
+    public static final String ROOT_TRUST = "0.8";
+    public static final String PROVENANCE_ACTION_CLASS = "sysimport:dedup";
+    public static final String PROVENANCE_ACTIONS = "dnet:provenanceActions";
+
+    public SparkPrepareOrgRels(ArgumentApplicationParser parser, SparkSession spark) {
+        super(parser, spark);
+    }
+
+    public static void main(String[] args) throws Exception {
+        ArgumentApplicationParser parser = new ArgumentApplicationParser(
+                IOUtils
+                        .toString(
+                                SparkCreateSimRels.class
+                                        .getResourceAsStream(
+                                                "/eu/dnetlib/dhp/oa/dedup/prepareOrgRels_parameters.json")));
+        parser.parseArgument(args);
+
+        SparkConf conf = new SparkConf();
+        conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer");
+        conf.registerKryoClasses(ModelSupport.getOafModelClasses());
+
+        new SparkCreateDedupRecord(parser, getSparkSession(conf))
+                .run(ISLookupClientFactory.getLookUpService(parser.get("isLookUpUrl")));
+    }
+
+    @Override
+    public void run(ISLookUpService isLookUpService) throws IOException {
+
+        final String graphBasePath = parser.get("graphBasePath");
+        final String isLookUpUrl = parser.get("isLookUpUrl");
+        final String actionSetId = parser.get("actionSetId");
+        final String workingPath = parser.get("workingPath");
+        final String apiUrl = parser.get("apiUrl");
+        final String dbUrl = parser.get("dbUrl");
+        final String dbTable = parser.get("dbTable");
+        final String dbUser = parser.get("dbUser");
+        final String dbPwd = parser.get("dbPwd");
+
+        log.info("graphBasePath: '{}'", graphBasePath);
+        log.info("isLookUpUrl:   '{}'", isLookUpUrl);
+        log.info("actionSetId:   '{}'", actionSetId);
+        log.info("workingPath:   '{}'", workingPath);
+        log.info("apiUrl:        '{}'", apiUrl);
+        log.info("dbUrl:         '{}'", dbUrl);
+        log.info("dbUser:        '{}'", dbUser);
+        log.info("table:         '{}'", dbTable);
+        log.info("dbPwd:         '{}'", "xxx");
+
+        final String mergeRelPath = DedupUtility.createMergeRelPath(workingPath, actionSetId, "organization");
+        final String entityPath = DedupUtility.createEntityPath(graphBasePath, "organization");
+
+        Dataset<OrgSimRel> relations = createRelations(spark, mergeRelPath, entityPath);
+
+        final Properties connectionProperties = new Properties();
+        connectionProperties.put("user", dbUser);
+        connectionProperties.put("password", dbPwd);
+
+        relations.write().mode(SaveMode.Overwrite).jdbc(dbUrl, dbTable, connectionProperties);
+
+        if (!apiUrl.isEmpty())
+            updateSimRels(apiUrl);
+
+    }
+
+    public static Dataset<OrgSimRel> createRelations(
+            final SparkSession spark,
+            final String mergeRelsPath,
+            final String entitiesPath) {
+
+        // <id, json_entity>
+        Dataset<Tuple2<String, Organization>> entities = spark
+                .read()
+                .textFile(entitiesPath)
+                .map(
+                        (MapFunction<String, Tuple2<String, Organization>>) it -> {
+                            Organization entity = OBJECT_MAPPER.readValue(it, Organization.class);
+                            return new Tuple2<>(entity.getId(), entity);
+                        },
+                        Encoders.tuple(Encoders.STRING(), Encoders.kryo(Organization.class)));
+
+        Dataset<Tuple2<String, String>> relations = spark.createDataset(
+                spark
+                        .read()
+                        .load(mergeRelsPath)
+                        .as(Encoders.bean(Relation.class))
+                        .where("relClass == 'merges'")
+                        .toJavaRDD()
+                        .mapToPair(r -> new Tuple2<>(r.getSource(), r.getTarget()))
+                        .groupByKey()
+                        .flatMap(g -> {
+                            List<Tuple2<String, String>> rels = new ArrayList<>();
+                            for (String id1 : g._2()) {
+                                for (String id2 : g._2()) {
+                                    if (!id1.equals(id2))
+                                        if (id1.contains("openorgs"))
+                                            rels.add(new Tuple2<>(id1, id2));
+                                }
+                            }
+                            return rels.iterator();
+                        }).rdd(),
+                Encoders.tuple(Encoders.STRING(), Encoders.STRING()));
+
+        return relations
+                .joinWith(entities, relations.col("_2").equalTo(entities.col("_1")), "inner")
+                .map(
+                        (MapFunction<Tuple2<Tuple2<String, String>, Tuple2<String, Organization>>, OrgSimRel>)r ->
+                                new OrgSimRel(
+                                        r._1()._2(),
+                                        r._2()._2().getOriginalId().get(0),
+                                        r._2()._2().getLegalname().getValue(),
+                                        r._2()._2().getLegalshortname().getValue(),
+                                        r._2()._2().getCountry().getClassid(),
+                                        r._2()._2().getWebsiteurl().getValue(),
+                                        r._2()._2().getCollectedfrom().get(0).getValue()
+                                ),
+                        Encoders.bean(OrgSimRel.class)
+                );
+
+    }
+
+    private static String updateSimRels(final String apiUrl) throws IOException {
+        final HttpGet req = new HttpGet(apiUrl);
+        try (final CloseableHttpClient client = HttpClients.createDefault()) {
+            try (final CloseableHttpResponse response = client.execute(req)) {
+                return IOUtils.toString(response.getEntity().getContent());
+            }
+        }
+    }
+
+}

dhp-workflows/dhp-dedup-openaire/src/main/resources/eu/dnetlib/dhp/oa/dedup/orgsdedup/oozie_app/config-default.xml

@@ -0,0 +1,18 @@
+<configuration>
+    <property>
+        <name>jobTracker</name>
+        <value>yarnRM</value>
+    </property>
+    <property>
+        <name>nameNode</name>
+        <value>hdfs://nameservice1</value>
+    </property>
+    <property>
+        <name>oozie.use.system.libpath</name>
+        <value>true</value>
+    </property>
+    <property>
+        <name>oozie.action.sharelib.for.spark</name>
+        <value>spark2</value>
+    </property>
+</configuration>

dhp-workflows/dhp-dedup-openaire/src/main/resources/eu/dnetlib/dhp/oa/dedup/orgsdedup/oozie_app/workflow.xml

@@ -0,0 +1,212 @@
+<workflow-app name="Duplicate Scan" xmlns="uri:oozie:workflow:0.5">
+    <parameters>
+        <property>
+            <name>graphBasePath</name>
+            <description>the raw graph base path</description>
+        </property>
+        <property>
+            <name>isLookUpUrl</name>
+            <description>the address of the lookUp service</description>
+        </property>
+        <property>
+            <name>actionSetId</name>
+            <description>id of the actionSet</description>
+        </property>
+        <property>
+            <name>workingPath</name>
+            <description>path for the working directory</description>
+        </property>
+        <property>
+            <name>dedupGraphPath</name>
+            <description>path for the output graph</description>
+        </property>
+        <property>
+            <name>cutConnectedComponent</name>
+            <description>max number of elements in a connected component</description>
+        </property>
+        <property>
+            <name>apiUrl</name>
+            <description>the url for the APIs of the openorgs service</description>
+        </property>
+        <property>
+            <name>dbUrl</name>
+            <description>the url of the database</description>
+        </property>
+        <property>
+            <name>dbUser</name>
+            <description>the user of the database</description>
+        </property>
+        <property>
+            <name>dbTable</name>
+            <description>the name of the table in the database</description>
+        </property>
+        <property>
+            <name>dbPwd</name>
+            <description>the passowrd of the user of the database</description>
+        </property>
+        <property>
+            <name>sparkDriverMemory</name>
+            <description>memory for driver process</description>
+        </property>
+        <property>
+            <name>sparkExecutorMemory</name>
+            <description>memory for individual executor</description>
+        </property>
+        <property>
+            <name>sparkExecutorCores</name>
+            <description>number of cores used by single executor</description>
+        </property>
+        <property>
+            <name>oozieActionShareLibForSpark2</name>
+            <description>oozie action sharelib for spark 2.*</description>
+        </property>
+        <property>
+            <name>spark2ExtraListeners</name>
+            <value>com.cloudera.spark.lineage.NavigatorAppListener</value>
+            <description>spark 2.* extra listeners classname</description>
+        </property>
+        <property>
+            <name>spark2SqlQueryExecutionListeners</name>
+            <value>com.cloudera.spark.lineage.NavigatorQueryListener</value>
+            <description>spark 2.* sql query execution listeners classname</description>
+        </property>
+        <property>
+            <name>spark2YarnHistoryServerAddress</name>
+            <description>spark 2.* yarn history server address</description>
+        </property>
+        <property>
+            <name>spark2EventLogDir</name>
+            <description>spark 2.* event log dir location</description>
+        </property>
+    </parameters>
+
+    <global>
+        <job-tracker>${jobTracker}</job-tracker>
+        <name-node>${nameNode}</name-node>
+        <configuration>
+            <property>
+                <name>mapreduce.job.queuename</name>
+                <value>${queueName}</value>
+            </property>
+            <property>
+                <name>oozie.launcher.mapred.job.queue.name</name>
+                <value>${oozieLauncherQueueName}</value>
+            </property>
+            <property>
+                <name>oozie.action.sharelib.for.spark</name>
+                <value>${oozieActionShareLibForSpark2}</value>
+            </property>
+        </configuration>
+    </global>
+
+    <start to="resetWorkingPath"/>
+
+    <kill name="Kill">
+        <message>Action failed, error message[${wf:errorMessage(wf:lastErrorNode())}]</message>
+    </kill>
+
+    <action name="resetWorkingPath">
+        <fs>
+            <delete path="${workingPath}"/>
+        </fs>
+        <ok to="CreateSimRel"/>
+        <error to="Kill"/>
+    </action>
+
+    <action name="CreateSimRel">
+        <spark xmlns="uri:oozie:spark-action:0.2">
+            <master>yarn</master>
+            <mode>cluster</mode>
+            <name>Create Similarity Relations</name>
+            <class>eu.dnetlib.dhp.oa.dedup.SparkCreateSimRels</class>
+            <jar>dhp-dedup-openaire-${projectVersion}.jar</jar>
+            <spark-opts>
+                --executor-memory=${sparkExecutorMemory}
+                --executor-cores=${sparkExecutorCores}
+                --driver-memory=${sparkDriverMemory}
+                --conf spark.extraListeners=${spark2ExtraListeners}
+                --conf spark.sql.queryExecutionListeners=${spark2SqlQueryExecutionListeners}
+                --conf spark.yarn.historyServer.address=${spark2YarnHistoryServerAddress}
+                --conf spark.eventLog.dir=${nameNode}${spark2EventLogDir}
+                --conf spark.sql.shuffle.partitions=3840
+            </spark-opts>
+            <arg>--graphBasePath</arg><arg>${graphBasePath}</arg>
+            <arg>--isLookUpUrl</arg><arg>${isLookUpUrl}</arg>
+            <arg>--actionSetId</arg><arg>${actionSetId}</arg>
+            <arg>--workingPath</arg><arg>${workingPath}</arg>
+            <arg>--numPartitions</arg><arg>8000</arg>
+        </spark>
+        <ok to="copyRelations"/>
+        <error to="Kill"/>
+    </action>
+
+    <action name="copyRelations">
+        <distcp xmlns="uri:oozie:distcp-action:0.2">
+            <arg>-pb</arg>
+            <arg>${graphBasePath}/relation</arg>
+            <arg>${workingPath}/organization_simrel</arg>
+        </distcp>
+        <ok to="CreateMergeRel"/>
+        <error to="Kill"/>
+    </action>
+
+    <action name="CreateMergeRel">
+        <spark xmlns="uri:oozie:spark-action:0.2">
+            <master>yarn</master>
+            <mode>cluster</mode>
+            <name>Create Merge Relations</name>
+            <class>eu.dnetlib.dhp.oa.dedup.SparkCreateMergeRels</class>
+            <jar>dhp-dedup-openaire-${projectVersion}.jar</jar>
+            <spark-opts>
+                --executor-memory=${sparkExecutorMemory}
+                --executor-cores=${sparkExecutorCores}
+                --driver-memory=${sparkDriverMemory}
+                --conf spark.extraListeners=${spark2ExtraListeners}
+                --conf spark.sql.queryExecutionListeners=${spark2SqlQueryExecutionListeners}
+                --conf spark.yarn.historyServer.address=${spark2YarnHistoryServerAddress}
+                --conf spark.eventLog.dir=${nameNode}${spark2EventLogDir}
+                --conf spark.sql.shuffle.partitions=3840
+            </spark-opts>
+            <arg>--graphBasePath</arg><arg>${graphBasePath}</arg>
+            <arg>--workingPath</arg><arg>${workingPath}</arg>
+            <arg>--isLookUpUrl</arg><arg>${isLookUpUrl}</arg>
+            <arg>--actionSetId</arg><arg>${actionSetId}</arg>
+            <arg>--cutConnectedComponent</arg><arg>${cutConnectedComponent}</arg>
+        </spark>
+        <ok to="PrepareOrgRels"/>
+        <error to="Kill"/>
+    </action>
+
+    <action name="PrepareOrgRels">
+        <spark xmlns="uri:oozie:spark-action:0.2">
+            <master>yarn</master>
+            <mode>cluster</mode>
+            <name>Prepare Organization Relations</name>
+            <class>eu.dnetlib.dhp.oa.dedup.SparkPrepareOrgRels</class>
+            <jar>dhp-dedup-openaire-${projectVersion}.jar</jar>
+            <spark-opts>
+                --executor-memory=${sparkExecutorMemory}
+                --executor-cores=${sparkExecutorCores}
+                --driver-memory=${sparkDriverMemory}
+                --conf spark.extraListeners=${spark2ExtraListeners}
+                --conf spark.sql.queryExecutionListeners=${spark2SqlQueryExecutionListeners}
+                --conf spark.yarn.historyServer.address=${spark2YarnHistoryServerAddress}
+                --conf spark.eventLog.dir=${nameNode}${spark2EventLogDir}
+                --conf spark.sql.shuffle.partitions=3840
+            </spark-opts>
+            <arg>--graphBasePath</arg><arg>${graphBasePath}</arg>
+            <arg>--workingPath</arg><arg>${workingPath}</arg>
+            <arg>--isLookUpUrl</arg><arg>${isLookUpUrl}</arg>
+            <arg>--actionSetId</arg><arg>${actionSetId}</arg>
+            <arg>--apiUrl</arg><arg>${apiUrl}</arg>
+            <arg>--dbUrl</arg><arg>${dbUrl}</arg>
+            <arg>--dbTable</arg><arg>${dbTable}</arg>
+            <arg>--dbUser</arg><arg>${dbUser}</arg>
+            <arg>--dbPwd</arg><arg>${dbPwd}</arg>
+        </spark>
+        <ok to="End"/>
+        <error to="Kill"/>
+    </action>
+
+    <end name="End"/>
+</workflow-app>

dhp-workflows/dhp-dedup-openaire/src/main/resources/eu/dnetlib/dhp/oa/dedup/prepareOrgRels_parameters.json

@@ -0,0 +1,56 @@
+[
+  {
+    "paramName": "i",
+    "paramLongName": "graphBasePath",
+    "paramDescription": "the base path of raw graph",
+    "paramRequired": true
+  },
+  {
+    "paramName": "w",
+    "paramLongName": "workingPath",
+    "paramDescription": "the working directory path",
+    "paramRequired": true
+  },
+  {
+    "paramName": "la",
+    "paramLongName": "isLookUpUrl",
+    "paramDescription": "the url of the lookup service",
+    "paramRequired": true
+  },
+  {
+    "paramName": "asi",
+    "paramLongName": "actionSetId",
+    "paramDescription": "the id of the actionset (orchestrator)",
+    "paramRequired": true
+  },
+  {
+    "paramName": "au",
+    "paramLongName": "apiUrl",
+    "paramDescription": "the url for the APIs of the openorgs service",
+    "paramRequired": true
+  },
+  {
+    "paramName": "du",
+    "paramLongName": "dbUrl",
+    "paramDescription": "the url of the database",
+    "paramRequired": true
+  },
+  {
+    "paramName": "dusr",
+    "paramLongName": "dbUser",
+    "paramDescription": "the user of the database",
+    "paramRequired": true
+  },
+  {
+    "paramName": "t",
+    "paramLongName": "dbTable",
+    "paramDescription": "the name of the table in the database",
+    "paramRequired": true
+  },
+  {
+    "paramName": "dpwd",
+    "paramLongName": "dbPwd",
+    "paramDescription": "the password for the user of the database",
+    "paramRequired": true
+  }
+]