[FAB-16217] Do not load JSON Schema schema from network

Currently, the JSON Schema schema (http://json-schema.org/draft-04/schema)
is loaded from the network every time the Java chaincode starts. This has
been seen to cause delays/hangs in the CI system, and we should avoid it
if possible.

This CR adds the JSON Schema schema to the chaincode resources, and uses
that copy (instead of the network copy) to validate any contract schemas.

Signed-off-by: Simon Stone <[email protected]>
Change-Id: Ic559fb5f1a07f86bcd4d2eb2003c791e71abc701
(cherry picked from commit 4371d07)

Author: Simon Stone

fabric-chaincode-shim/src/main/java/org/hyperledger/fabric/contract/metadata/MetadataBuilder.java

@@ -8,6 +8,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.Serializable;
+import java.net.URI;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -19,7 +20,9 @@
 
 import org.everit.json.schema.Schema;
 import org.everit.json.schema.ValidationException;
+import org.everit.json.schema.loader.SchemaClient;
 import org.everit.json.schema.loader.SchemaLoader;
+import org.everit.json.schema.loader.internal.DefaultSchemaClient;
 import org.hyperledger.fabric.Logger;
 import org.hyperledger.fabric.contract.annotation.Contract;
 import org.hyperledger.fabric.contract.annotation.Info;
@@ -61,17 +64,27 @@ V putIfNotNull(K key, V value) {
     static Map<String, Object> overallInfoMap = new HashMap<String, Object>();
     static Map<String, Object> componentMap = new HashMap<String, Object>();
 
+    // The schema client used to load any other referenced schemas
+    static SchemaClient schemaClient = new DefaultSchemaClient();
+
     /**
      * Validation method
      *
      * @throws ValidationException if the metadata is not valid
      */
     public static void validate() {
         logger.info("Running schema test validation");
-        try (InputStream inputStream = MetadataBuilder.class.getClassLoader()
-                .getResourceAsStream("contract-schema.json")) {
-            JSONObject rawSchema = new JSONObject(new JSONTokener(inputStream));
-            Schema schema = SchemaLoader.load(rawSchema);
+        ClassLoader cl = MetadataBuilder.class.getClassLoader();
+        try (InputStream contractSchemaInputStream = cl.getResourceAsStream("contract-schema.json");
+             InputStream jsonSchemaInputStream = cl.getResourceAsStream("json-schema-draft-04-schema.json")) {
+            JSONObject rawContractSchema = new JSONObject(new JSONTokener(contractSchemaInputStream));
+            JSONObject rawJsonSchema = new JSONObject(new JSONTokener(jsonSchemaInputStream));
+            SchemaLoader schemaLoader = SchemaLoader.builder()
+                .schemaClient(schemaClient)
+                .schemaJson(rawContractSchema)
+                .registerSchemaByURI(URI.create("http://json-schema.org/draft-04/schema"), rawJsonSchema)
+                .build();
+            Schema schema = schemaLoader.load().build();
             schema.validate(metadata());
 
         } catch (IOException e) {

fabric-chaincode-shim/src/main/resources/json-schema-draft-04-schema.json

@@ -0,0 +1,149 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "$schema": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}

fabric-chaincode-shim/src/test/java/org/hyperledger/fabric/contract/metadata/MetadataBuilderTest.java

@@ -5,18 +5,26 @@
 */
 package org.hyperledger.fabric.contract.metadata;
 
+import java.io.InputStream;
 import java.io.Serializable;
 import java.util.HashMap;
 
+import org.everit.json.schema.loader.SchemaClient;
+import org.everit.json.schema.loader.internal.DefaultSchemaClient;
 import org.hyperledger.fabric.contract.ChaincodeStubNaiveImpl;
 import org.hyperledger.fabric.contract.Context;
+import org.hyperledger.fabric.contract.routing.ContractDefinition;
+import org.hyperledger.fabric.contract.routing.impl.ContractDefinitionImpl;
 import org.hyperledger.fabric.contract.systemcontract.SystemContract;
 import org.hyperledger.fabric.shim.ChaincodeStub;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
+import contract.SampleContract;
+
 public class MetadataBuilderTest {
     @Rule
     public ExpectedException thrown = ExpectedException.none();
@@ -34,10 +42,12 @@ public class MetadataBuilderTest {
             + "          \"contact\": {\"email\": \"[email protected]\"}\n" + "       }\n" + "    }\n" + "";
 
     @Before
-    public void beforeEach() {
+    @After
+    public void beforeAndAfterEach() {
         MetadataBuilder.componentMap = new HashMap<String, Object>();
         MetadataBuilder.contractMap = new HashMap<String, HashMap<String, Serializable>>();
         MetadataBuilder.overallInfoMap = new HashMap<String, Object>();
+        MetadataBuilder.schemaClient = new DefaultSchemaClient();
     }
 
     @Test
@@ -49,4 +59,19 @@ public void systemContract() {
         String metadataCompressed = system.getMetadata(new Context(stub));
     }
 
+    @Test
+    public void defaultSchemasNotLoadedFromNetwork() {
+        ContractDefinition contractDefinition = new ContractDefinitionImpl(SampleContract.class);
+        MetadataBuilder.addContract(contractDefinition);
+        MetadataBuilder.schemaClient = new SchemaClient(){
+
+            @Override
+            public InputStream get(String uri) {
+                throw new RuntimeException("Refusing to load schema: " + uri);
+            }
+
+        };
+        MetadataBuilder.validate();
+    }
+
 }