diff --git a/dhp-workflows/dhp-dedup/src/test/java/eu/dnetlib/dedup/SparkCreateDedupTest.java b/dhp-workflows/dhp-dedup/src/test/java/eu/dnetlib/dedup/SparkCreateDedupTest.java index f93703e37..5d534713f 100644 --- a/dhp-workflows/dhp-dedup/src/test/java/eu/dnetlib/dedup/SparkCreateDedupTest.java +++ b/dhp-workflows/dhp-dedup/src/test/java/eu/dnetlib/dedup/SparkCreateDedupTest.java @@ -75,10 +75,10 @@ public class SparkCreateDedupTest { final HashFunction hashFunction = Hashing.murmur3_128(); - System.out.println( s1.hashCode()); - System.out.println(hashFunction.hashUnencodedChars(s1).asLong()); - System.out.println( s2.hashCode()); - System.out.println(hashFunction.hashUnencodedChars(s2).asLong()); +// System.out.println( s1.hashCode()); +// System.out.println(hashFunction.hashUnencodedChars(s1).asLong()); +// System.out.println( s2.hashCode()); +// System.out.println(hashFunction.hashUnencodedChars(s2).asLong()); } diff --git a/dhp-workflows/dhp-doiboost/pom.xml b/dhp-workflows/dhp-doiboost/pom.xml new file mode 100644 index 000000000..ddff95fea --- /dev/null +++ b/dhp-workflows/dhp-doiboost/pom.xml @@ -0,0 +1,53 @@ + + + + dhp-workflows + eu.dnetlib.dhp + 1.1.6-SNAPSHOT + + 4.0.0 + + dhp-doiboost + + + + + org.apache.hadoop + hadoop-client + + + + org.apache.httpcomponents + httpclient + 4.3.4 + + + + + eu.dnetlib.dhp + dhp-common + ${project.version} + + + org.apache.cxf + cxf-rt-transports-http + + + + + + eu.dnetlib.dhp + dhp-schemas + ${project.version} + + + com.jayway.jsonpath + json-path + + + + + + + \ No newline at end of file diff --git a/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/CrossrefImporter.java b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/CrossrefImporter.java new file mode 100644 index 000000000..fae14101e --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/CrossrefImporter.java @@ -0,0 +1,65 @@ +package eu.dnetlib.doiboost; + +import eu.dnetlib.dhp.application.ArgumentApplicationParser; +import org.apache.commons.io.IOUtils; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.io.IntWritable; +import org.apache.hadoop.io.SequenceFile; +import org.apache.hadoop.io.Text; +import org.apache.http.HttpHost; + + + +public class CrossrefImporter { + + + + public static void main(String[] args) throws Exception { + + final ArgumentApplicationParser parser = new ArgumentApplicationParser(IOUtils.toString(CrossrefImporter.class.getResourceAsStream("/eu/dnetlib/dhp/doiboost/import_from_es.json"))); + parser.parseArgument(args); + System.out.println(parser.get("targetPath")); + + + final String hdfsuri = parser.get("namenode"); + System.out.println(hdfsuri); + Path hdfswritepath = new Path(parser.get("targetPath")); + + + // ====== Init HDFS File System Object + Configuration conf = new Configuration(); + // Set FileSystem URI + conf.set("fs.defaultFS", hdfsuri); + // Because of Maven + conf.set("fs.hdfs.impl", org.apache.hadoop.hdfs.DistributedFileSystem.class.getName()); + conf.set("fs.file.impl", org.apache.hadoop.fs.LocalFileSystem.class.getName()); + + + + ESClient client = new ESClient("ip-90-147-167-25.ct1.garrservices.it", "crossref"); + + try (SequenceFile.Writer writer = SequenceFile.createWriter(conf, + SequenceFile.Writer.file(hdfswritepath), SequenceFile.Writer.keyClass(IntWritable.class), + SequenceFile.Writer.valueClass(Text.class))) { + + + int i = 0; + long start= System.currentTimeMillis(); + long end = 0; + final IntWritable key = new IntWritable(i); + final Text value = new Text(); + while (client.hasNext()) { + key.set(i++); + value.set(client.next()); + writer.append(key, value); + if (i % 100000 == 0) { + end = System.currentTimeMillis(); + final float time = (end - start) / 1000; + System.out.println(String.format("Imported %d records last 100000 imported in %f seconds", i, time)); + start = System.currentTimeMillis(); + } + } + } + } +} diff --git a/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/ESClient.java b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/ESClient.java new file mode 100644 index 000000000..99f430aca --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/ESClient.java @@ -0,0 +1,103 @@ +package eu.dnetlib.doiboost; + +import com.jayway.jsonpath.JsonPath; +import org.apache.commons.io.IOUtils; +import org.apache.http.client.methods.CloseableHttpResponse; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.entity.StringEntity; +import org.apache.http.impl.client.CloseableHttpClient; +import org.apache.http.impl.client.HttpClients; + +import java.io.IOException; +import java.util.Iterator; +import java.util.List; + +public class ESClient implements Iterator { + + final static String blobPath = "$.hits[*].hits[*]._source.blob"; + final static String scrollIdPath = "$._scroll_id"; + + String scrollId; + + List buffer; + + final String esHost; + final String esIndex; + + public ESClient(final String esHost, final String esIndex) throws IOException { + + this.esHost = esHost; + this.esIndex = esIndex; + final String body =getResponse(String.format("http://%s:9200/%s/_search?scroll=1m", esHost, esIndex), "{\"size\":1000}"); + scrollId= getJPathString(scrollIdPath, body); + buffer = getBlobs(body); + + } + + + private String getResponse(final String url,final String json ) { + CloseableHttpClient client = HttpClients.createDefault(); + try { + + HttpPost httpPost = new HttpPost(url); + if (json!= null) { + StringEntity entity = new StringEntity(json); + httpPost.setEntity(entity); + httpPost.setHeader("Accept", "application/json"); + httpPost.setHeader("Content-type", "application/json"); + } + CloseableHttpResponse response = client.execute(httpPost); + + return IOUtils.toString(response.getEntity().getContent()); + } catch (Throwable e) { + throw new RuntimeException("Error on executing request ",e); + } finally { + try { + client.close(); + } catch (IOException e) { + throw new RuntimeException("Unable to close client ",e); + } + } + + } + + private String getJPathString(final String jsonPath, final String json) { + try { + Object o = JsonPath.read(json, jsonPath); + if (o instanceof String) + return (String) o; + return null; + } catch (Exception e) { + return ""; + } + } + + private List getBlobs(final String body) { + final List res = JsonPath.read(body, "$.hits.hits[*]._source.blob"); + return res; + } + + + @Override + public boolean hasNext() { + return (buffer!= null && !buffer.isEmpty()); + + } + + @Override + public String next() { + final String nextItem = buffer.remove(0); + if (buffer.isEmpty()) { + final String json_param = String.format("{\"scroll_id\":\"%s\",\"scroll\" : \"1m\"}", scrollId); + final String body =getResponse(String.format("http://%s:9200/_search/scroll", esHost), json_param); + try { + buffer = getBlobs(body); + } catch (Throwable e) { + System.out.println(body); + + } + + } + return nextItem; + } +} diff --git a/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/Journal.scala b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/Journal.scala new file mode 100644 index 000000000..d6c1abfca --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/Journal.scala @@ -0,0 +1,16 @@ +package eu.dnetlib.doiboost + + + +case class Journal( + JournalId: Long, + Rank: Int, + NormalizedName: String, + DisplayName: String, + Issn: String, + Publisher: String, + Webpage: String, + PaperCount: Long, + CitationCount: Long, + CreatedDate: String + ) diff --git a/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/SparkDownloadContentFromCrossref.scala b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/SparkDownloadContentFromCrossref.scala new file mode 100644 index 000000000..fa5ea7b0b --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/java/eu/dnetlib/doiboost/SparkDownloadContentFromCrossref.scala @@ -0,0 +1,49 @@ +package eu.dnetlib.doiboost + +//import org.apache.spark.SparkConf +//import org.apache.spark.sql.{Dataset, Encoders, Row, SparkSession} +// +//object SparkDownloadContentFromCrossref { +// +// +// def main(args: Array[String]): Unit = { +// +// +// val conf: SparkConf = new SparkConf().setAppName("DownloadContentFromCrossref").setMaster("local[*]") +// +// val spark = SparkSession.builder().config(conf).getOrCreate() +// +// +// val sc = spark.sparkContext +// import spark.implicits._ +// spark.read.option("header", "false") +// .option("delimiter", "\t") +// .csv("/Users/sandro/Downloads/doiboost/mag_Journals.txt.gz") +// +// +// val d = spark.read.option("header", "false") +// .option("delimiter", "\t") +// .csv("/Users/sandro/Downloads/doiboost/mag_Journals.txt.gz") +// .map(f => +// Journal( f.getAs[String](0).toLong, f.getAs[String](1).toInt, f.getAs[String](2), +// f.getAs[String](3), f.getAs[String](4), f.getAs[String](5), f.getAs[String](6), +// f.getAs[String](7).toLong, f.getAs[String](8).toLong, f.getAs[String](9) +// )) +// +// d.show() +// +// d.printSchema() +// +// +// +// +// +// +// +// +// } +// +// +//} +// + diff --git a/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/application/oozie_app/config-default.xml b/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/application/oozie_app/config-default.xml new file mode 100644 index 000000000..9f009a781 --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/application/oozie_app/config-default.xml @@ -0,0 +1,18 @@ + + + jobTracker + yarnRM + + + nameNode + hdfs://nameservice1 + + + oozie.action.sharelib.for.java + spark2 + + + oozie.launcher.mapreduce.user.classpath.first + true + + \ No newline at end of file diff --git a/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/application/oozie_app/workflow.xml b/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/application/oozie_app/workflow.xml new file mode 100644 index 000000000..a6484e794 --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/application/oozie_app/workflow.xml @@ -0,0 +1,39 @@ + + + + workingPath + the working dir base path + + + + + + + + Action failed, error message[${wf:errorMessage(wf:lastErrorNode())}] + + + + + + + + + + + + + + + + ${jobTracker} + ${nameNode} + eu.dnetlib.doiboost.CrossrefImporter + -t${workingPath}/input/crossref/index_dump + -n${nameNode} + + + + + + \ No newline at end of file diff --git a/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/import_from_es.json b/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/import_from_es.json new file mode 100644 index 000000000..7992f535d --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/main/resources/eu/dnetlib/dhp/doiboost/import_from_es.json @@ -0,0 +1,4 @@ +[ + {"paramName":"t", "paramLongName":"targetPath", "paramDescription": "the path of the sequencial file to write", "paramRequired": true}, + {"paramName":"n", "paramLongName":"namenode", "paramDescription": "the hive metastore uris", "paramRequired": true} +] \ No newline at end of file diff --git a/dhp-workflows/dhp-doiboost/src/test/java/eu/dnetlib/doiboost/DoiBoostTest.java b/dhp-workflows/dhp-doiboost/src/test/java/eu/dnetlib/doiboost/DoiBoostTest.java new file mode 100644 index 000000000..87dcb548d --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/test/java/eu/dnetlib/doiboost/DoiBoostTest.java @@ -0,0 +1,61 @@ +package eu.dnetlib.doiboost; + +import com.jayway.jsonpath.JsonPath; +import org.apache.commons.io.IOUtils; +import org.junit.Assert; +import org.junit.Ignore; +import org.junit.Test; + +import java.io.IOException; +import java.util.List; + +public class DoiBoostTest { + + @Test + @Ignore + public void test() throws Exception { + //SparkDownloadContentFromCrossref.main(null); + CrossrefImporter.main(new String[]{ + "-n","file:///tmp", + "-t","file:///tmp/p.seq", + }); + } + + + @Test + public void testPath() throws Exception { + final String json = IOUtils.toString(getClass().getResourceAsStream("response.json")); + + final List res = JsonPath.read(json, "$.hits.hits[*]._source.blob"); + + + + System.out.println(res.size()); + + } + + + @Test + @Ignore + public void testParseResponse() throws IOException { + long end, start = System.currentTimeMillis(); + ESClient client = new ESClient("ip-90-147-167-25.ct1.garrservices.it", "crossref"); + + + int i = 0; + while (client.hasNext()) { + Assert.assertNotNull(client.next()); + i++; + if(i % 1000 == 0) { + end = System.currentTimeMillis(); + System.out.println("Vel 1000 records in "+((end -start)/1000)+"s"); + start = System.currentTimeMillis(); + } + + + if (i >1000000) + break; + } + } + +} diff --git a/dhp-workflows/dhp-doiboost/src/test/resources/eu/dnetlib/doiboost/response.json b/dhp-workflows/dhp-doiboost/src/test/resources/eu/dnetlib/doiboost/response.json new file mode 100644 index 000000000..3249e312f --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/test/resources/eu/dnetlib/doiboost/response.json @@ -0,0 +1,127 @@ +{ + "_scroll_id": "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", + "took": 89, + "timed_out": false, + "_shards": { + "total": 240, + "successful": 240, + "skipped": 0, + "failed": 0 + }, + "hits": { + "total": 113109351, + "max_score": 1.0, + "hits": [ + { + "_index": "crossref", + "_type": "item", + "_id": "10.26850/1678-4618eqj.v35.1.2010.p41-46", + "_score": 1.0, + "_source": { + "timestamp": 1540825815212, + "pid": "10.26850/1678-4618eqj.v35.1.2010.p41-46", + "blob": "eF69V9tyE0cQ/ZUpPXsvs9rVDSpVYIeKKSdc7OQhhIfRbksae2+emRUWFP+e07OSLYFNMFWEMiDP9HSf7j590afByavTwUwMZBwmo0kWR3I0ngTpSE7o+jJcD7NQhkmM2zaVOB4ciYG2tqMCjz4NCuUoaJVxFr++ewfByZGQ+Mnev/8MUTW3zqjcsYWnl8rZWfvLM3HdqVI75fSahG0bFziyTqi6EA7/UMUCtdtJqFqVG6utaBai0O3GNDUJXQu3IjHvyitRmG7Jj3HWrpSpVE6d07kqRWsI4GCoqa2AhtY0bWOpCMUFHi8ayPIda1bCUFFouwrWuinJ/dPFsYpF3pSNgeYC+oASYlCgPXJDtitdKE5rYem6ozonXB9Ah72cis6QyFUt5iRaMmyVPFh2wKoKQEplr3pMB897C3B87pSu8egDQZXlyFnvYLkBwAou8p12K6iEe3vy/RmJinDDRns/CjHfePPPjfqoS63qrbuv+/ghSqTVkeisrpde8Nx1BdWIClI8tWKbLVy8EJw8G4pjxFgXZHYv8gYBqZF9H2G4q4SMYwFDw3l+JsCA665xR177PiHW2oIeotSVdj7l5CjvdSD886ZzImO0xVjGwUgsn0A3SNZVMIZ3Z69OYCNJ0kzIML0VTEXV4DKQ4glE3uxE0vBO161I+DTaUpXZDg4t9M1+ifCp6hBQw6T/5D/DuGdIETQm11wcC1VaguQSXKn5+e/KuZWmjp8vVKXLDZ9edHNdN3y2IxGfLrSxzttZLDg/7D8be4+jV2+PT09YaOVcO4sibzBszDKK8SfA3ySQ08k4GE7j8QBVCIRfa7mF9QypCw8xPYe14itMCuXBOFS5Vfq9bhunxO/KaCVOOrQKEsfKrFW58hbuIvGXLtWXcdiz+ePBAGMnwTgejx6F+4zgqunDcAfyNX38+DNQDgOgHAfj4Wj6KJS/UUm1Em+p0Eu0qsOI/iywMsiyURrI0RBgmZIoEXQm1HuQN13N3T7G6en5+R9M2sHtSBmwcEXVnLh0BlIOp5lPedOZnPjo2DTWQp0/zRvDhzJkbQX5zrsdPE5XaDuqavk+S+NJMsySKbjPkjyUWIAV8kgK0CmS6YVMZ8NkFk//ZuX3Ty48T6b96EKvpJsHrWUTmSUy+Za1bCbjmcy+z5rbtB7uJSKBCgtQJzoviZG23bzEXOLWUpcYAxD778H759szVrdtEcVNWDTa94hHzfngNrFFMN8cJHfdlGi5bGPoU4iloA62XqAn7vwBPXOHia1zFkLVd/7NHSM8f+DWFY7x7hC3IUwDp0J9HXY12Tacm6i5tJHPTdiu2ogQJO680TZg0VrThxe6pEhOZSTTqcdWO8KLIlBtW3Kb7rvpwNGNCypdY2SxGCYW5FywJmO3Emv0+L2bnVd7eqK2WPQV+79CtxiPJXqqQ1ZWlF892oWuti3leqFBcZ+DHfP8duc5tvs0kD9GQ14AbwlkD9hjMTwdTjCywWiDanUgO/eKXzmhoXjT6SoUL0PfMXYV4JuGF0ASvQj//7Ivmf08FU0FvX2h7D762Zlze6mUuQKzsTRov1hAzg9rxgt6UG09lC/JmBvyKys2rgq7jq+mrbiN5psoDWPGAL4a7oCogYMeJbPpOE15RN/fo2IZyOwijmf+5xtd4267voew+2kFmIJKtQl0HRRqwyt67FPtPbm3tclxNo0nafIgyCSIkws5ZpBp8jBINMZk20a3dOpJdJfn89u9H0sjlqfFti791wCjWl0crtL9duQ0Vrz+CwHv83vfCDxRHiAUb4E03ZLG/1IcMMdzTC19Z0rl4PO/owMhhQ==" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.18410/jebmh/2018/575", + "_score": 1.0, + "_source": { + "timestamp": 1541495459193, + "pid": "10.18410/jebmh/2018/575", + "blob": "eF6dVNtO4zAQ/RXLz02TlKa0fQslQFYlrXrRakEImcRpDUmctZ0KVPHvO5NQKKsu2903ezyey5kzZ0vPJyEdEuo6bbffdR37kT/ka7vjuH3bO/Voi1ChdcUTcNrShBlulUwZDdfbW/RqkUGLdLy7u1dwLRVPxfN+PAzAKrOWCn9sKUtTkQlmhCzQcAfPK7HheKG+2ogiwR8py0X2grYZy9Gg+c+KFzFHUyqUNvQVv0I6rtBuxbIqDLw6YA3n8wiD085Jd2B1vF4HQ7xdTh2KP3OeP3CsiZ6ednt1ClmpJsFISa0hdG2NpcKsbhsjJ7yUWpg3NIzIuTYsL/Hd67rdQdfr9Byn9kSk0AFTIE6W61pOb+H0h5437PRuMPhBOF23RXoNnIAGf/5jMq/rDdzByVfJBkPXGXqDo5KZl7Iu9hFwKFhmwZRFnHGss6weMqHXPLFkkYkC3f7OheVsjOHWxpRD206e24kUbalW9pdUs95HmlgPL5/GupFZ1eC5o2VhvRUNxNqVXyoBRICiNyyrGvTfWQAU/XDkGY+NkoWID3kDTWqGQbtPyKUt3etHQ0P1nrRjmdtMa260DcNk92WS2r5iyON7oO69dX8RRv64DXbMAqVxmGlisbLMRLxbA6oF8J0pYaDjNY+fRLFC91iiv7E2XOlmYegGFmnvZdd1VeiSxyIVwJa67o+RNYAcM7Hd5OuFr2e8O9Gu8988+OdKUEjeWaA/UUAqsRJITiMMUBN3PChWyM16qTXIjIEPhWHAUrXnVU+r9tmVU+/+mG94RpYlOas0/NCajABv0IU9iBOZQ7SG8rtjrVsxykTO1BNwVhsl4jdRS1mmOTYRKw4q0CjnQa3wjtIK76j1/W1UHwD5ZL5Ynv8gk4iMxmEUjvwxmc4mF+E4IH50Tq79yL8MroNoQSYXZOovQjjO8XwVzKbBnNxM5otgRibTq8WVP74OR8s5CSNyvpxd+tPlrEW+B/MFOQuiS39cQ3xoAN8aVSEyJcFGJKjZ5IxpnpBrnogYwCesSMgVZ5lZxww0tx4WWzUr3Hf6VqfvuvT1F2Qb/lQ=" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.26686/lew.v0i0.1330", + "_score": 1.0, + "_source": { + "timestamp": 1543961469345, + "pid": "10.26686/lew.v0i0.1330", + "blob": "eF61Vu9v2zYQ/VcIoQU2wLIl+UdtY9iAdR3aIeuAOl2AFvlASyeLiURqJGVHC/q/7x1tZ07gdNuHAf4gU6e7d+/e3fE++um3d9FSRGkyzGaz+WxU0264TVQyTMfjJBqISDnXUQGb+6iQnuJWWu/w9/PndPEqGYgUv+vrL7CUa+etzD37++5Gerdsv7+sSLynnfhEspa6EI3SqukasZMbEhb+RCWdsJST9nUv6K4lq0jnVAgpXOe8VBrPfGoKYUqxsWbnK+Er6UVtzK0TjrzwRuRGe6U7Ep0uyMKARN5ZC7/iQq5NZ+MajjZmS1Y3OB2KlUIckSVJFqxl0dX+GYCwtCQdHKx7kc1fitKaRryYC86pgnNGcBoypAa4L5jY6VBcVgppKkdC6WD4iAjmwHQe9Km25dQBkgliltxA7CqVV/jwBEM6fSk4leDLyYYOFB0itRKMic6RCwanFXhrcFyZujjQIn42FjSsOrulPuSjvBPvdG7gdNW1bU1MFyeoCjyosn8MfmfsLVkXPi3I5VatiaMqi7+N2VjZAn94fWPWIq8kiwQFdV7lbohQgjWl8q6WdhDw7uHTnQRLSAGfaBBxpO6JB6b5EZtHQGvyOyK9rzCHR6lRil9PJXiwHRzJRJX2WhsIaaFQqqVXW4I0e9PpjfgmkC6h2roMFqhQIdJZnE1FT9K6bweitVQYIJJB0iU1siYUETQpeOBcY69ALkNiF7W65QAgGMRR09amh0/oRIoV2a3KkTrbruCHewWQ8N7kedcCnIEdF20vqw+EjqnDyVvjWuVlrXyPtwV6CZ0Fvn88RwvTDig7CFHi2RLFJWvkKLqjf4fqBWGHBuYwDo1t+5Aeq+CgEcUqdmfrcr4CHIDrI3aMw9VqUzF7wMB8I05jnlJ1ZBZKBakIuFOYDNzPZ0X1AL2RFkwUh8og4cagLmclVJhuzWODAZwwpJ/n5aybQ3HeYggCITt7bZqm01yahxIfatRjoOXe2OF3o8MM5SkMTZXq7nRS86nsfGUsD+P7SJalqlUQBB9c4/UGyuU/0S/S4RQnJTqq7vnoUjWA6vjQ0R8dj1w+LpV1PvrCXyMiSoHzOIf0eapj2kfvVqv37D/KJrNxnM2SJGLjhpo1MZIoTbNsEtxiLO6dvrbGObgLpznqCLt0yN4Kao1TkDNO7iPuCkz8puX308l4MV3MX02TJFjy7mEDjpEl6TxOsziZXGbpcjJZjqef2PmTBcVm2E7ZQEz2GwoU091zwWbpZLYYT6ZfC5Yt03SZLP5VMN+3AewNeNCyjsOMqylUE6pSrqIiNrrGiAvZ/8N2/fjhgr1V3rfL0ai4GxZGDY3djL62uuOHIhbxun9USOx1HR8wQj5HtFRDfdZolTPQray7PeMP1Q7aAOhboMF3J7AccJkbN8TEgn6VHMp8qP8cXby5Gh1yHxVmp2sjixHfLkZputhfMbQnVKaIJbaNyo8ajjzd+ZgbSm8YDG94LKAYE9jtVR5tof6TN8ckTvyM2qKMcDv5f5E6hb6SFv0c5xXlPOj/G+JOu5ZyVWIuPek+96hqDv3ucaLDxciiIzwkxf0ImkMnHrUVmvH3QynER41ZANowcDC8r6hGBTceu+NCrS3m9ylaLC8432vy+BjmSc59jOl5C1nxNskPw6aUtSO+AfIF5XwzZ+NFOklm8+eaOZnE6YybOXu1nMyf768J+nm2b+a/Uz9u9CveSVfHRaRPrz1LcVWZsG0xxvsfAlNnWQxXxYF4E9ZwuPjwuGanvKFOLlLR9Ze/AK09uI8=" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.30707/etd2017.mckinnis.r", + "_score": 1.0, + "_source": { + "timestamp": 1544632883454, + "pid": "10.30707/etd2017.mckinnis.r", + "blob": "eF69VE1v2zAM/SuCz3FiO9++DdulWIoWSXtZkINi0wlRWdIkOYgR5L+PtNMCLdZtpwE2LNOk3uPToy+RbfYK/RFclIvoTinUBr3YBBlAPGs8gfMY2mggosLoADrEpaklakq/RG/L7Y4TnPG+lu4lduCDwyKg4bxKKg9XSvj2cMcoaTIcJ/NkPoJQZkk6H9bFC2qNfugYx0EFDnQBPi5MowOVJBQu4eAA6GUb3W8ixpNNOBrmvb1EsqpQobwhdnQORJ7hozWgUq1YyVYDA1SyRtXyl/viewfMUQ8/G0bleIXOh+jKuzyvVxw5hmDz0ag8D0uDQ+MOo790gd43UFIpqURaxla64JnrVjdK7Xasx1un7xotHFBBXxqwJillbakynU4ms3EynmZJ0gnC23IC8yMdF3Ga0fWUTvPpMk+zH9zVB2xOG4g047vngJ5O6yZ4Ge/bd1Sktc6cft8Gn9xALAciW/Y71VDvexulWTqbd5qaxvWKfmVvEBBHLT3xzKxfNexyC+O4lXTYn7Y1ZLz/J4Mu4fwpWrZYjCfTyZ9En+WTNM/G/yZ6wKB6K2+KI5QNTd1BrIEs73PxCKSZZSd78VCJVaOLozOmFpvGgjuhN84PxBNIKuXVF12KR4e6QCtVNxihtZ0pSjIhOBplnkOKo/aE3NyGhIaGJla3NbsyirtKq2R3Xq/vWvb2+vzHcL3+ApKoSns=" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.5209/rev_esmp.2001.v17.n1.13", + "_score": 1.0, + "_source": { + "timestamp": 1502718217884, + "pid": "10.5209/rev_esmp.2001.v17.n1.13", + "blob": "eF6NlG9v0zAQxr+KlVcgNZmdpM2ftxsvJm2AGBMSo5rc+Lp5OHZkO2XTtO/OXdptFIrgXes73z1+7nd5TE4+nCYtSwTP5jlvjjxsriH0Q5ZzLrKNqDIrMlEkM5boEEZQmPyYKBkhHaSPAf9eXeVciBkTfMbK5fIJUwcPa33/S126H8bVHXSRbiTHru9HqzsZtbPJEqNyjLfOU/Axkeu1NnobwwMK3+gNWCp4Aisvqdxa9to80NEXCFEakzxRInYGD7aDtHOjpW4oKzm9uHg/NRZNXaf5ollQCSGKMhWLvJkU9NCvgBQkhVg0k2I3+g7o5Ni7ELD0dNo5T4cio8oKBhd03BkTdU9i+oHiZV4v8qqaN5xPmX+YNkfDyLcltZ/CdJ/6oaPzlKM4/pmLludt0XxNyFltFdwfajbneSXqXFR1jTUPNKtmrMZmOKEDzaqU16koP4uiLYu2qLbN4sMwqblDH6w0KQ5cdwbIhGFcGR1uQaXOGm0p7d9YXH46o3K3MQ7t0ZG6z5TTmfM3R/9FX/oyWpWuHvbGu3Fm3Bonqh2qNt2pR56e3zF4jUSg+o004/SyVwLQ3NdEMAiqdwjofvYLPBNqyv2wxkl1Pa2BmPOa13neNBmfl1WOCS+Cw57agKBHPLFRonMehx7RVKLzXYijytg52CDvgH0Er53KJjqfDZ8AvbS4Dj5oJRXDVRrMGPEKMAXsXCqvFXtzeXz+lsRTG7AxVa7HbtsxPf+cNqsjtHvpv6O/IXrdTSvZsrU0AQi5zgOiuV38Pb4LUdfzxaJEvA/zvfsoiOogcwLpTkVFzPGy5XwHOH1lptGQ+ldrziRzK9g+Wdu1tFEbBpYZyfBrg34xCIP8NnK+Fs7IybO/WqxdYMGtPDAwv7lNFUAFBN0ly6eflnaEwg==" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.1345/1542-6270(2001)035<1096:rahcri>2.0.co;2", + "_score": 1.0, + "_source": { + "timestamp": 1502583760457, + "pid": "10.1345/1542-6270(2001)035<1096:rahcri>2.0.co;2", + "blob": "eF6dVG1r2zAQ/ivCn1qIUsmvsTcGIRttx7qWJGOwUoYiK7U6xzKS3CWU/vfdOUlLRtfCEn+wT/fo3p7nHoKPl+dBQQLOhjyKkxOexCFNw4wdhYzxYxYl7znL08KKSlr9IRyyoTTvwmBAAu1cp0oAPwSl8Iq2wnoHn9fXCB2Q/ObmEdxaq5Z6vY/BswyxrlvcKenRO7iqhF0JaWpzuyFHK1VqKerj4AbcROcrY9HrIRDLpa618No0aMDjW32v8CO4MJUAIBnj3Uux0vUGzZcrYQPI4XXwZ4A6cnUI/a5rB4HeBM8FxBBkdoiemHXwiBlC7cqqRioqTddgvQys57PZ1750zlJGWThiCH9qfV/6Sq0WCksPeJb3LTOdlQoNE2ucg5t7qzQWjXyIF5eqNU773VS8hsK8WLV4HoejNIyilMEPPf+eGE8GJO6Htj9FOIYLGU8oiynL52FUxHkRsh/YmEA3pVq/FCthYTKKspTFSfZiLLCOBoRHLwbLKBtRHs0ZK8KwiHfB/Kbts7mDNjSipkA2LWuFPfg2/YInlfdtcXJSroel0UNjb0/+i9T0aWYlXWye5ga9Ce5N3W17EiUYGBTQ0F1iwNB9iq3VMGr0F3XXJ/08555Qe0dVgwasabQ89N5rcMuh0vxuaiPKn726eMJG+A/5cJSDZHOI03aLWrtKlXQb+i1JPlXoDmi5v6Zn3Wx8+olc4cWy15zDFKVpvGo8Lc1KaFQeSH//2itSIjVBEb+gi85bLXdyXYraKeSMtAqYt90aB/xkcZamuDj+wU8WDQg8PH6JMyyi8PB4zrOCR0XItwT12gNDUGjTSiwg042pN047IpqSnF2c0okZk6kqO+mFU+S8qfRCe2PddvnUXgHVPCwZqjFj1OvrW3I6PptMz/stObmELdm3BHoGzVKWPqczrxQZN0BjR8yS7Begr5QV7aZHteJ2x5w8pZyzLHj8A8nNo4g=" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.15707/disem.2015.26.3.002", + "_score": 1.0, + "_source": { + "timestamp": 1502556112306, + "pid": "10.15707/disem.2015.26.3.002", + "blob": "eF6NVE1vnDAQ/SsWh54W1jYYA7eq6SHql9SkhzZZVcY2CQ1gBCbNKsp/74x3Nx/qVukFwczzm8fMG99HJ19Oo4pEjCZMSCrXpp1tn3DKRMLzJE0o5dGKRO08L9YA8j4yytt4VJOf4fPiAqErUmw2DwAbJ9u0d88J8bBa/LWbEH0fqaZpu1b51g0Y2EC6UX3bbfHQdzVcrciZczfxJ2sjYHzlwOWiC5pdLnVqSniXUv/fIckpwEuNz5yy6AF1gHY72UHbWLtl8CCIQvT07OwzKo1YKfM4KySLENzbvrb4T1GeAQFEZrdM2mLk3eTmGdhCVLsJgyxBMmNHN7d+30nf9nb2qh8xn4mC84yXOaUB+VeX8xVJV4TJDZYPaTyP9WAEeUzTmMlzllWsqFj+A/sQtYOxd8eKCcqFyBnjKQXaI8UkjBSK8aPFZEyLmPFzllcZqwTfFfPbMaj5BX0YVBeDQ1rdWWzCt68fMXPt/Vit1+YuMa5N3HS1ft128eNUTFxvX0zm1nXLvgFi79Eh3qsApx30jFMLwwQVt6pbgsKnSYa5G/d76JwyP4OjmaAFlTCGLEmLXHAGiHGpu3a+tibekb22Bo+a5xeCZ9gCD5HBq3awE8zPQ3/QW7B1qoa98Fvbj53b9hYko7ZD5eC0D2AlRd4/IsjbK7DrljRuIv7akhNk6axZP4Oc2FvbuREJyekwQ8nFh5mgDAjGxvWgBuhhsw+vYS01urhX0w2MYPZTq/c726hutuguDWqOWzmjAjv4TyvjhbEiPD/qLoHu4vk5LStKK3qwMl5A2IQUxT91Drde6cvF5AKetW7gNtCFhMVWuhEQF6IkT7tucOMLhtBUA1RpSjEtFWC1yDEtZYFPUWBCaEjUdYq0nEHCiAKuGiDXmGaBymYhrTII1aWGEEhghxpaGKxR1w3yWgHPmpeIxbsHGZUgFXwqbcOFpPAuKxqkgcvliDzEGszXBf61lmXQvVO8k8+NwZpBmTIC8nUpg+SSQU3NbTiY7kmC2Y45M3gqOJO8eWa9nTnV1W4kIs7K6OEPZADnVg==" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.2202/1234-1234.1004", + "_score": 1.0, + "_source": { + "timestamp": 1502749524652, + "pid": "10.2202/1234-1234.1004", + "blob": "eF6VVGFP2zAQ/StWPuxT09pO0ib5yhAwsYFWpklD1eQmbmNw7Mh2gArx33fnliEm2DSpSpPz+d7zu3d+TD5enCU1SRidck75jPEsT/ExZZTmyYQkyvtRtpDzmLQiyHQQLnj4vL7mlC4mhMFvtXqCzMHJjXo4VGMFK3C7H9c3sgm4IVnaRllttzsiTEsurVZBNUKTZaOkaSSmn4v7ZAX/YgyddbjrMRGbjdJKBGUNBnB5q+4kfiSfRq0kOepU2u1igY3old7h0nK8TZ4wGWhJhwBpY0eDVChEz5bLL5EVq7Iy5UVeROBe9muJwEm2iOf3dnTADQJHznoPxWK0sQ6DbIq1WjlYr8JBpqB66YPoB1zPqzzL5gsQl8bMPyVkIGExIdUKweMqbkc4TtkipUVKqyuW1RmvKf+RoM7KtPLhLayC8kVeFTyfF/w9rBLalb8HVqYsv+K85kXN8z1Y2A2RzQ3IYIROofuq0VHqYVxr5TvZptZoZTDtnx759vUcq3UhDPVs1j5MW6um1m1nfzNg+ruDbbreverindXjXi52MKtJD5TBOc/kpQYLOmtUg0l3Qo/xTC+djz5p7b3RVrQ/o79ZQUtazvN5OZ1nOSugTy9O8q9IeLBqgIgJAmRw0MEACqG3wM7kAzkOnWo8sRtyOvbCkK9q2wEGYj5rGB33XeggHWklOXHjDl9P+vUpUsba0oS0tT1A7IV+fo0D0aA3e+FuQSsfnGoO07IR2ks0TeMkmGs/x68MyhYFzXlWVu8YFGc8mxBevmUaCg7NUl5eUVpnVZ1XB4finREVRvIvchzDOWyvGnIxDCDZaOACkD7eBqGT5NLZAI2COUetPitjnQo7ci7MdhRbuVfs/2V++gUcDnPL" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.2202/1234-1234.1006", + "_score": 1.0, + "_source": { + "timestamp": 1502749524653, + "pid": "10.2202/1234-1234.1006", + "blob": "eF6VVF1r2zAU/SvCD3uqEkmWEsdvYxttofsg6RishKHYSqJOloIsdw2l/333KmlLR7sxCI59dHXP8blHvivefz4valJwNhKCiTEXpaR4GXHGJsUJKWzfD6aFmrui1cnQnY6ph8erK8HY9IRw+C2X91C5i2Ztb4/duOIKt/fD6to0CTcUi9DY4MJmT7RvyZfgbLKNdmTRWOMbg+UX+lexhH89pG2IuOuu0Ou1dVYnGzwCuLyxNwYfircOQADWurNuj8iZjsYV91gFekzEzrQJg0cNDNDzxeJTlsNnZUWFkiozdqZbGWQsyqnMysMQQRQA72Loe2iW0SZEBPkIe7VmF3qbjv4k25k+6W6H63ImS8lLMInlyj+94+CdOiGzJZLnVdyOdILxKWWKstkll7Wsasm+F2iw9a25fYlLMTGVMyXkRJWvcVUwJ/kaWUW5vBSiFqoW8kCW9rus5hps8NpRGLttXB7Sblg5229NS4N31mPZP8PxdX6B3bYp7erxuL0dtcGOQtyM/5Y8+jjBlq72z6Z4E9xwsIsfU+rpUTJE5kG8cZC9GLxtsOhGuyG/09Pkc07a8Mu7oNsfOdhcsYpVEzmpRpNSqukEKh519M9E9JDRBIhPGmyIMMEEDmG2IMfkDfmQtrbpSViTs6HTnsztZgscyPngYU7cN+2SiaQ15DQOe7w97VZnKBl7G59oGzqgOBj9cJtPQoPZ7HT8CV71KdrmeEzW2vUGQ9NEA+E6HOBnAeVTxaSQTL0SUDzckCZRvRQaBgktqaguGYN41kwdE4ofi+wwin+yY242g4MT7DfkY2hB6J7ODQAGPgNRg+bGHGz5fy/vfwMeHmcs" + } + }, + { + "_index": "crossref", + "_type": "item", + "_id": "10.5433/1980-511.2008v3n1p107", + "_score": 1.0, + "_source": { + "timestamp": 1502757844220, + "pid": "10.5433/1980-511.2008v3n1p107", + "blob": "eF6NVNtu2zAM/RXBz7Ej2Vac+G1r91Cg2IpegGFdMCiWkmqTJU+Ss17Qfx9pJ72h7fZgQKYoHvLwkHfJ4ZejpCYJoxkvi2LKFnOacsaynNL5trCsY7RKJiTRIfRKgutdIkVUaSd8DPB7eYmeE1JNCOPL5T24dl6t9fWTqPhe9PHKeXxwl4j1WhstonYWDUu43uitwp/kwOsQtbCOfPQ6Ony6Fq02N3h5rG0gBy5EkQDQ+4E+WOm/95SqBTl3RskXoU6d9HrTq9vkHvEhZeWVbVTauN5GAKNgPTo7+4wZJntavibo3Kp2pbCWpOCcY4rB9b5RY/4uBIg2WBvn0cgyDCZV54KOOxKjbhXU0XZ4X7JZnlcMmKSD50uCWQnsMviqJeIP9xgAAXPKypSxlFXnLK9zXuf0G7KTaCvV9WtonOYVr+Zlmeevo0EvoaPYzlfAqpTOU8bPKa3LsqblCBZvuiGbn0CEFSYFdejGKGSh61dGhyslU2eNtuj2bw1dnB5juKsYu3o6ldeZdDpzfjP9D6GmD82U6ermWUO3zvQjbcVO1DbdpQ663BehjGqid1Y36LQVph9qexTBIBnp/ljjhPwxzAHjdE7nszmbZbSYFXwGHg95hGdJBBiECBYbBdDhoZMRmEKZnaptRg61z8gJkta4QW57AgfFXViYFB+0FFKRT6Ag2QtD4HzsQPDaCkwZYysbU+lagBgJ3x+HcWs8qLQV/hdwFaLXzW4W18IEheJpvAKRjfP+TKrFgi/yGePsHakWE5K/pVRapDkotagZrznbKRV3y8AwJv9Ix8FugCUsAixRtzBBcAxu5RXpvJN9dIGA0HssQhh9KyQYwNOGvoVT41oizLAG5O/eRUFulR9ZfYN/2D6CSIddUAh7go/X4kk3xGbMFfbi/V9eupFL" + } + } + ] + } +} diff --git a/dhp-workflows/dhp-doiboost/src/test/resources/eu/dnetlib/doiboost/s.json b/dhp-workflows/dhp-doiboost/src/test/resources/eu/dnetlib/doiboost/s.json new file mode 100644 index 000000000..a201d51a0 --- /dev/null +++ b/dhp-workflows/dhp-doiboost/src/test/resources/eu/dnetlib/doiboost/s.json @@ -0,0 +1,4 @@ +{ + "scroll_id": "DnF1ZXJ5VGhlbkZldGNo8AEAAAAAAAJmBRYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAAByUWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAckFmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAHPBZrdjMxVmw2R1JicURDbHdrRHo0Q1VRAAAAAAAABykWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAcqFmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAHKBZrdjMxVmw2R1JicURDbHdrRHo0Q1VRAAAAAAAABycWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAc6Fmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAHJhZrdjMxVmw2R1JicURDbHdrRHo0Q1VRAAAAAAACZgcWM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAAcrFmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAJmBhYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAACZggWM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAAjjFmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAAHLRZrdjMxVmw2R1JicURDbHdrRHo0Q1VRAAAAAAAABywWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAcvFmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAJmCxYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAABz0Wa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAcuFmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAI4hZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAACZgkWM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAmYPFjNsWU1LeTlrVGhPZERWRW9iWEZ5QlEAAAAAAAAHMxZrdjMxVmw2R1JicURDbHdrRHo0Q1VRAAAAAAAABzAWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAc0Fmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAI5BZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAAABzEWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAcyFmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAI5RZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAACZg4WM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAAc1Fmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAJmERYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAABzYWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAmYSFjNsWU1LeTlrVGhPZERWRW9iWEZ5QlEAAAAAAAJmDBYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAABzcWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAjmFmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAJmExYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAACOEWaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAAlVFkR4bkItaG5ZUzhXVWFrVnlDdks3WlEAAAAAAAAJUhZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAACVEWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAmYKFjNsWU1LeTlrVGhPZERWRW9iWEZ5QlEAAAAAAAAJUxZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAACVcWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAmYNFjNsWU1LeTlrVGhPZERWRW9iWEZ5QlEAAAAAAAAJURZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACVQWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAAlWFkR4bkItaG5ZUzhXVWFrVnlDdks3WlEAAAAAAAAHOBZrdjMxVmw2R1JicURDbHdrRHo0Q1VRAAAAAAAABzkWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAc7Fmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAI5xZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAACZhAWM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAAlSFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAALIxY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACVoWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAmTOFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAAI6BZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAACZM8WVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAjpFmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAJmFBYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAACVMWcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAskFjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAJWBZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAABz4Wa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAptFjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAJk0BZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACOoWaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAAc_Fmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAJVRZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACyUWOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAAlZFkR4bkItaG5ZUzhXVWFrVnlDdks3WlEAAAAAAAJk0hZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACm4WMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAmTRFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAAI6xZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAACZhUWM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAAlUFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAALJhY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACVsWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAAdAFmt2MzFWbDZHUmJxRENsd2tEejRDVVEAAAAAAAAKbxYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAACZNMWVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAjsFmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAJmFhYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAACVYWcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAsnFjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAJXBZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAACVcWcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAApwFjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAJk1BZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACO0WaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAAlYFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAAJWRZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACygWOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAAldFkR4bkItaG5ZUzhXVWFrVnlDdks3WlEAAAAAAAAKchYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAAACnEWMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAmTVFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAAI7hZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAAACykWOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAAlbFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAALLRY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACV4WRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAAssFjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAKcxYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAACZNYWVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAjvFmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAJmFxYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAACVoWcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAsqFjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAJXxZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAACZNcWVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAp0FjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAJk2BZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACPAWaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAmYYFjNsWU1LeTlrVGhPZERWRW9iWEZ5QlEAAAAAAAAJXBZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACysWOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAAp1FjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAAKdxYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAAACnYWMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAmTZFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAJk2hZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACV0WcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAleFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAALLhY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACWEWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAAlgFkR4bkItaG5ZUzhXVWFrVnlDdks3WlEAAAAAAAAKeRYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAACZNsWVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAjxFmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAJmGRYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAACV8WcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAsvFjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAJYhZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAACzAWOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAAp4FjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAJk3BZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACPIWaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAmYaFjNsWU1LeTlrVGhPZERWRW9iWEZ5QlEAAAAAAAAJYBZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACzEWOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAmTfFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAALMhY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACnoWMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAmTdFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAAJYxZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAACWQWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAAlhFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAALMxY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACWUWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAAliFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAAKexYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAACZN4WVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAjzFmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAAJZhZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACWMWcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAs0FjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAJZhZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAACWQWcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAp8FjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAJk4BZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACPQWaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAmYbFjNsWU1LeTlrVGhPZERWRW9iWEZ5QlEAAAAAAAAJZRZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACzUWOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAAlnFkR4bkItaG5ZUzhXVWFrVnlDdks3WlEAAAAAAAALNhY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACn0WMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAmThFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAAI9RZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAACZhwWM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAAlnFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAALNxY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACWgWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAAs4FjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAKfhYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAACZOUWVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAj2Fmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAJmHRYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAACWgWcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAs5FjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAJk4xZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAAB0EWa3YzMVZsNkdSYnFEQ2x3a0R6NENVUQAAAAAAAAp_FjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAJk4hZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACPcWaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAAs6FjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAJaRZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACzsWOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAAlpFkR4bkItaG5ZUzhXVWFrVnlDdks3WlEAAAAAAAAI-BZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAAACoAWMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAmTkFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAAI-RZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAAACoEWMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAAlqFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAALPBY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACWoWRHhuQi1obllTOFdVYWtWeUN2SzdaUQAAAAAAAAqCFjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAAKgxYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAACZOYWVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAj6Fmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAJmHhYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAACWsWcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAs9FjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAJaxZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAACoQWMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAAqFFjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAJk5xZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACPsWaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAAqKFjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAAJbBZwaDlETnJ4alJDeUZYdGlLck9XQ3dBAAAAAAAACz4WOUdGNk1zckRTN21CZDBxOEpFUGZjUQAAAAAAAAlsFkR4bkItaG5ZUzhXVWFrVnlDdks3WlEAAAAAAAAJbRZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAAACoYWMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAmToFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAAI_BZpc2tXeFY1dlQ1S2MtVVg0NWhEVm9BAAAAAAACZh8WM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAAltFnBoOUROcnhqUkN5Rlh0aUtyT1dDd0EAAAAAAAALPxY5R0Y2TXNyRFM3bUJkMHE4SkVQZmNRAAAAAAAACocWMnJWMHhRZE5SVXU0Rm9wYVI1QUU0QQAAAAAAAmTpFlRHZW4xZGhFUnVPbXBCWlNhWF9kYWcAAAAAAAAKiRYyclYweFFkTlJVdTRGb3BhUjVBRTRBAAAAAAACZOoWVEdlbjFkaEVSdU9tcEJaU2FYX2RhZwAAAAAAAAj9Fmlza1d4VjV2VDVLYy1VWDQ1aERWb0EAAAAAAAJmIBYzbFlNS3k5a1RoT2REVkVvYlhGeUJRAAAAAAAACW4WcGg5RE5yeGpSQ3lGWHRpS3JPV0N3QQAAAAAAAAtAFjlHRjZNc3JEUzdtQmQwcThKRVBmY1EAAAAAAAAJbhZEeG5CLWhuWVM4V1Vha1Z5Q3ZLN1pRAAAAAAACZiEWM2xZTUt5OWtUaE9kRFZFb2JYRnlCUQAAAAAAAAqIFjJyVjB4UWROUlV1NEZvcGFSNUFFNEEAAAAAAAJk6xZUR2VuMWRoRVJ1T21wQlpTYVhfZGFnAAAAAAAACP4WaXNrV3hWNXZUNUtjLVVYNDVoRFZvQQAAAAAAAmYiFjNsWU1LeTlrVGhPZERWRW9iWEZ5QlE=", + "size": 100 +} diff --git a/dhp-workflows/pom.xml b/dhp-workflows/pom.xml index 05bfe677d..ce38b8180 100644 --- a/dhp-workflows/pom.xml +++ b/dhp-workflows/pom.xml @@ -19,6 +19,7 @@ dhp-graph-mapper dhp-dedup dhp-graph-provision + dhp-doiboost diff --git a/pom.xml b/pom.xml index f47d49ea7..fe5c1c2e7 100644 --- a/pom.xml +++ b/pom.xml @@ -1,178 +1,178 @@ + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> - 4.0.0 - eu.dnetlib.dhp - dhp - 1.1.6-SNAPSHOT - pom + 4.0.0 + eu.dnetlib.dhp + dhp + 1.1.6-SNAPSHOT + pom - http://www.d-net.research-infrastructures.eu + http://www.d-net.research-infrastructures.eu - - - The Apache Software License, Version 2.0 - http://www.apache.org/licenses/LICENSE-2.0.txt - repo - A business-friendly OSS license - - + + + The Apache Software License, Version 2.0 + http://www.apache.org/licenses/LICENSE-2.0.txt + repo + A business-friendly OSS license + + - - dhp-build - dhp-schemas - dhp-common - dhp-workflows - + + dhp-build + dhp-schemas + dhp-common + dhp-workflows + - - Redmine - https://issue.openaire.research-infrastructures.eu/projects/openaire - + + Redmine + https://issue.openaire.research-infrastructures.eu/projects/openaire + - - jenkins - https://jenkins-dnet.d4science.org/ - + + jenkins + https://jenkins-dnet.d4science.org/ + - - scm:git:gitea@code-repo.d4science.org:D-Net/dnet-hadoop.git - scm:git:gitea@code-repo.d4science.org:D-Net/dnet-hadoop.git - https://code-repo.d4science.org/D-Net/dnet-hadoop/ - HEAD - + + scm:git:gitea@code-repo.d4science.org:D-Net/dnet-hadoop.git + scm:git:gitea@code-repo.d4science.org:D-Net/dnet-hadoop.git + https://code-repo.d4science.org/D-Net/dnet-hadoop/ + HEAD + - - + + - - - dnet45-releases - D-Net 45 releases - http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-releases - default - - false - - - true - - - - cloudera - Cloudera Repository - https://repository.cloudera.com/artifactory/cloudera-repos - - true - - - false - - - + + + dnet45-releases + D-Net 45 releases + http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-releases + default + + false + + + true + + + + cloudera + Cloudera Repository + https://repository.cloudera.com/artifactory/cloudera-repos + + true + + + false + + + - - - junit - junit - ${junit.version} - test - + + + junit + junit + ${junit.version} + test + - - org.mockito - mockito-core - 2.7.22 - test - + + org.mockito + mockito-core + 2.7.22 + test + - + - - - - org.apache.hadoop - hadoop-hdfs - ${dhp.hadoop.version} - provided - - - org.apache.hadoop - hadoop-common + + + + org.apache.hadoop + hadoop-hdfs + ${dhp.hadoop.version} + provided + + + org.apache.hadoop + hadoop-common ${dhp.hadoop.version} provided org.apache.hadoop hadoop-client - ${dhp.hadoop.version} - provided - - - org.apache.hadoop - hadoop-distcp - ${dhp.hadoop.version} - provided - - - org.apache.spark - spark-core_2.11 - ${dhp.spark.version} - provided - - - org.apache.spark - spark-sql_2.11 - ${dhp.spark.version} - provided - - - org.apache.spark - spark-graphx_2.11 - ${dhp.spark.version} - provided - + ${dhp.hadoop.version} + provided + + + org.apache.hadoop + hadoop-distcp + ${dhp.hadoop.version} + provided + + + org.apache.spark + spark-core_2.11 + ${dhp.spark.version} + provided + + + org.apache.spark + spark-sql_2.11 + ${dhp.spark.version} + provided + + + org.apache.spark + spark-graphx_2.11 + ${dhp.spark.version} + provided + - - org.slf4j - jcl-over-slf4j - 1.7.25 - provided - + + org.slf4j + jcl-over-slf4j + 1.7.25 + provided + - - org.apache.commons - commons-lang3 - ${dhp.commons.lang.version} - + + org.apache.commons + commons-lang3 + ${dhp.commons.lang.version} + - - com.google.guava - guava - ${dhp.guava.version} - + + com.google.guava + guava + ${dhp.guava.version} + - - commons-codec - commons-codec - 1.9 - + + commons-codec + commons-codec + 1.9 + - - commons-io - commons-io - 2.4 - + + commons-io + commons-io + 2.4 + - - commons-cli - commons-cli - 1.2 - provided - + + commons-cli + commons-cli + 1.2 + provided + net.sf.saxon @@ -180,25 +180,25 @@ 9.9.1-6 - - dom4j - dom4j - 1.6.1 - + + dom4j + dom4j + 1.6.1 + - - xml-apis - xml-apis - 1.4.01 - + + xml-apis + xml-apis + 1.4.01 + - - jaxen - jaxen - 1.1.6 - + + jaxen + jaxen + 1.1.6 + - + com.mycila.xmltool xmltool 3.3 @@ -249,47 +249,47 @@ - net.schmizz - sshj - 0.10.0 - test - + net.schmizz + sshj + 0.10.0 + test + - - com.fasterxml.jackson.core - jackson-core - ${dhp.jackson.version} - provided - + + com.fasterxml.jackson.core + jackson-core + ${dhp.jackson.version} + provided + - - com.fasterxml.jackson.core - jackson-annotations - ${dhp.jackson.version} - provided - - - com.fasterxml.jackson.core - jackson-databind - ${dhp.jackson.version} - provided - + + com.fasterxml.jackson.core + jackson-annotations + ${dhp.jackson.version} + provided + + + com.fasterxml.jackson.core + jackson-databind + ${dhp.jackson.version} + provided + - - eu.dnetlib - dnet-actionmanager-common - 6.0.5 - - - eu.dnetlib - dnet-openaire-data-protos - 3.9.8-proto250 - - - eu.dnetlib - dnet-pace-core - 4.0.0 - + + eu.dnetlib + dnet-actionmanager-common + 6.0.5 + + + eu.dnetlib + dnet-openaire-data-protos + 3.9.8-proto250 + + + eu.dnetlib + dnet-pace-core + 4.0.0 + eu.dnetlib cnr-rmi-api @@ -301,12 +301,12 @@ cxf-rt-transports-http 3.1.5 - - javax.persistence - javax.persistence-api - 2.2 - provided - + + javax.persistence + javax.persistence-api + 2.2 + provided + com.rabbitmq @@ -339,174 +339,174 @@ 4.0 - - org.apache.oozie - oozie-client - ${dhp.oozie.version} - provided - - - - slf4j-simple - org.slf4j - - - - - + + org.apache.oozie + oozie-client + ${dhp.oozie.version} + provided + + + + slf4j-simple + org.slf4j + + + + + - - target - target/classes - ${project.artifactId}-${project.version} - target/test-classes - - - - org.apache.maven.plugins - maven-compiler-plugin - ${maven.compiler.plugin.version} - - 1.8 - 1.8 - ${project.build.sourceEncoding} - - + + target + target/classes + ${project.artifactId}-${project.version} + target/test-classes + + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven.compiler.plugin.version} + + 1.8 + 1.8 + ${project.build.sourceEncoding} + + - - org.apache.maven.plugins - maven-jar-plugin - 3.0.2 - + + org.apache.maven.plugins + maven-jar-plugin + 3.0.2 + - - org.apache.maven.plugins - maven-source-plugin - 3.0.1 - - - attach-sources - verify - - jar-no-fork - - - - + + org.apache.maven.plugins + maven-source-plugin + 3.0.1 + + + attach-sources + verify + + jar-no-fork + + + + - - org.apache.maven.plugins - maven-surefire-plugin - 2.19.1 - - true - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.10.4 - - true - - - - org.apache.maven.plugins - maven-dependency-plugin - 3.0.0 - + + org.apache.maven.plugins + maven-surefire-plugin + 2.19.1 + + true + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.10.4 + + true + + + + org.apache.maven.plugins + maven-dependency-plugin + 3.0.0 + - - org.codehaus.mojo - build-helper-maven-plugin - 1.12 - - - - - - org.apache.maven.plugins - maven-release-plugin - 2.5.3 - - - org.jacoco - jacoco-maven-plugin - 0.7.9 - - - **/schemas/* - **/com/cloudera/**/* - **/org/apache/avro/io/**/* - - - - - default-prepare-agent - - prepare-agent - - - - default-report - prepare-package - - report - - - - + + org.codehaus.mojo + build-helper-maven-plugin + 1.12 + + + + + + org.apache.maven.plugins + maven-release-plugin + 2.5.3 + + + org.jacoco + jacoco-maven-plugin + 0.7.9 + + + **/schemas/* + **/com/cloudera/**/* + **/org/apache/avro/io/**/* + + + + + default-prepare-agent + + prepare-agent + + + + default-report + prepare-package + + report + + + + - + - - - org.apache.maven.wagon - wagon-ssh - 2.10 - - - - - - dnet45-snapshots - DNet45 Snapshots - http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots - default - - - dnet45-releases - http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-releases - - - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.10.4 - - true - - - - + + + org.apache.maven.wagon + wagon-ssh + 2.10 + + + + + + dnet45-snapshots + DNet45 Snapshots + http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots + default + + + dnet45-releases + http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-releases + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.10.4 + + true + + + + - - UTF-8 - UTF-8 - 3.6.0 - 2.22.2 - cdh5.9.2 - 2.6.0-${dhp.cdh.version} - 4.1.0-${dhp.cdh.version} - 2.4.0.cloudera2 - 2.9.6 - 3.5 - 11.0.2 - 2.11.12 - 4.12 - 3.4.2 - + + UTF-8 + UTF-8 + 3.6.0 + 2.22.2 + cdh5.9.2 + 2.6.0-${dhp.cdh.version} + 4.1.0-${dhp.cdh.version} + 2.4.0.cloudera2 + 2.9.6 + 3.5 + 11.0.2 + 2.11.12 + 4.12 + 3.4.2 +