Search in sources :

Example 6 with JsonSchema

use of com.github.fge.jsonschema.main.JsonSchema in project bender by Nextdoor.

the class BenderConfig method validate.

public static boolean validate(String data, ObjectMapper objectMapper, BenderSchema benderSchema) throws ConfigurationException {
    ProcessingReport report;
    try {
        /*
       * Create object
       */
        JsonNode node = objectMapper.readTree(data);
        /*
       * Create JSON schema
       */
        JsonNode jsonSchema = benderSchema.getSchema();
        /*
       * Validate
       */
        final JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
        final JsonSchema schema = factory.getJsonSchema(jsonSchema);
        report = schema.validate(node);
    } catch (IOException | ProcessingException ioe) {
        throw new ConfigurationException("unable to validate config", ioe);
    }
    if (report.isSuccess()) {
        return true;
    } else {
        throw new ConfigurationException("invalid config file", report.iterator().next().asException());
    }
}
Also used : ProcessingReport(com.github.fge.jsonschema.core.report.ProcessingReport) JsonSchema(com.github.fge.jsonschema.main.JsonSchema) JsonSchemaFactory(com.github.fge.jsonschema.main.JsonSchemaFactory) JsonNode(com.fasterxml.jackson.databind.JsonNode) IOException(java.io.IOException) ProcessingException(com.github.fge.jsonschema.core.exceptions.ProcessingException)

Example 7 with JsonSchema

use of com.github.fge.jsonschema.main.JsonSchema in project xm-ms-entity by xm-online.

the class JsonDataValidator method validate.

@SneakyThrows
private boolean validate(Map<String, Object> data, String jsonSchema) {
    String stringData = objectMapper.writeValueAsString(data);
    log.debug("Validation data. map: {}, jsonData: {}", data, stringData);
    JsonNode schemaNode = JsonLoader.fromString(jsonSchema);
    JsonNode dataNode = JsonLoader.fromString(stringData);
    JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
    JsonSchema schema = factory.getJsonSchema(schemaNode);
    val report = schema.validate(dataNode);
    boolean isSuccess = report.isSuccess();
    if (!isSuccess) {
        log.error("Validation data report: {}", report.toString().replaceAll("\n", " | "));
    }
    return isSuccess;
}
Also used : lombok.val(lombok.val) JsonSchema(com.github.fge.jsonschema.main.JsonSchema) JsonSchemaFactory(com.github.fge.jsonschema.main.JsonSchemaFactory) JsonNode(com.fasterxml.jackson.databind.JsonNode) SneakyThrows(lombok.SneakyThrows)

Example 8 with JsonSchema

use of com.github.fge.jsonschema.main.JsonSchema in project wso2-synapse by wso2.

the class ValidateMediator method mediate.

@SuppressWarnings({ "ThrowableResultOfMethodCallIgnored" })
public boolean mediate(MessageContext synCtx) {
    // This is the actual schema instance used to create a new schema
    Schema cachedSchema = null;
    JsonSchema cachedJsonSchema = null;
    if (synCtx.getEnvironment().isDebuggerEnabled()) {
        if (super.divertMediationRoute(synCtx)) {
            return true;
        }
    }
    SynapseLog synLog = getLog(synCtx);
    synLog.traceOrDebug("Start : Validate mediator");
    if (synLog.isTraceTraceEnabled()) {
        synLog.traceTrace("Message : " + synCtx.getEnvelope());
    }
    org.apache.axis2.context.MessageContext a2mc = ((Axis2MessageContext) synCtx).getAxis2MessageContext();
    if (JsonUtil.hasAJsonPayload(a2mc)) {
        ProcessingReport report;
        // This JsonSchema used if user decide not to cache the schema. In such a situation jsonSchema will not used.
        JsonSchema uncachedJsonSchema = null;
        JsonNode uncachedJsonSchemaNode = null;
        // flag to check if we need to initialize/re-initialize the schema
        StringBuilder combinedPropertyKey = new StringBuilder();
        StringBuilder cachedJsonSchemaKey = new StringBuilder();
        // if any of the schemas are not loaded, or have expired, load or re-load them
        boolean reCreate = !cacheSchema || isReCreate(synCtx, combinedPropertyKey);
        /*
             * Check for the cached schema in the map and if it's available get
             * the cached schema else re initialize the schema
             */
        if (cachedJsonSchemaMap.containsKey(combinedPropertyKey.toString())) {
            cachedJsonSchema = cachedJsonSchemaMap.get(combinedPropertyKey.toString());
        } else {
            reCreate = true;
        }
        // do not re-initialize schema unless required
        synchronized (validatorLock) {
            if (reCreate || cachedJsonSchema == null) {
                Object jsonSchemaObj = null;
                for (Value schemaKey : schemaKeys) {
                    // Derive actual key from message context
                    String propName = schemaKey.evaluateValue(synCtx);
                    jsonSchemaObj = synCtx.getEntry(propName);
                    cachedJsonSchemaKey.append(propName);
                }
                if (jsonSchemaObj == null) {
                    handleException("Can not find JSON Schema " + cachedJsonSchemaKey.toString(), synCtx);
                }
                try {
                    if (jsonSchemaObj instanceof String) {
                        if (cacheSchema) {
                            jsonSchemaNode = JsonLoader.fromString((String) jsonSchemaObj);
                        } else {
                            uncachedJsonSchemaNode = JsonLoader.fromString((String) jsonSchemaObj);
                        }
                    } else if (jsonSchemaObj instanceof OMTextImpl) {
                        // if Schema provides from registry
                        InputStreamReader reader = null;
                        try {
                            reader = new InputStreamReader(((OMTextImpl) jsonSchemaObj).getInputStream());
                            if (cacheSchema) {
                                jsonSchemaNode = JsonLoader.fromReader(reader);
                            } else {
                                uncachedJsonSchemaNode = JsonLoader.fromReader(reader);
                            }
                        } finally {
                            if (reader != null) {
                                try {
                                    reader.close();
                                } catch (IOException e) {
                                    log.warn("Error while closing registry resource stream. " + e);
                                }
                            }
                        }
                    } else {
                        handleException("Can not find valid JSON Schema content", synCtx);
                    }
                    if (cacheSchema) {
                        cachedJsonSchema = jsonSchemaFactory.getJsonSchema(jsonSchemaNode);
                        /*
                             * Initially adds the cached schema to the map if it's
                             * not available
                             */
                        if (!cachedJsonSchemaMap.containsKey(cachedJsonSchemaKey.toString())) {
                            cachedJsonSchemaMap.put(cachedJsonSchemaKey.toString(), cachedJsonSchema);
                        /*
                             * Removes the existing cached schema and adds the
                             * new cached schema This is used when editing a
                             * registry resource or when the cache expires
                             */
                        } else if (cachedJsonSchemaMap.containsKey(cachedJsonSchemaKey.toString())) {
                            cachedJsonSchemaMap.remove(cachedJsonSchemaKey.toString());
                            cachedJsonSchemaMap.put(cachedJsonSchemaKey.toString(), cachedJsonSchema);
                        }
                    } else {
                        uncachedJsonSchema = jsonSchemaFactory.getJsonSchema(uncachedJsonSchemaNode);
                    }
                } catch (ProcessingException | IOException e) {
                    handleException("Error while validating the JSON Schema", e, synCtx);
                }
            }
        }
        try {
            if (cachedJsonSchema == null && uncachedJsonSchema == null) {
                handleException("Failed to create JSON Schema Validator", synCtx);
            }
            String jsonPayload = null;
            if (sourcePath != null) {
                // evaluating
                if (sourcePath instanceof SynapseJsonPath) {
                    jsonPayload = sourcePath.stringValueOf(synCtx);
                } else {
                    handleException("Could not find the JSONPath evaluator for Source", synCtx);
                }
            } else {
                jsonPayload = JsonUtil.jsonPayloadToString(a2mc);
            }
            if (jsonPayload == null || jsonPayload.length() == 0) {
                // making empty json string
                jsonPayload = "{}";
            }
            if (cacheSchema) {
                report = cachedJsonSchema.validate(JsonLoader.fromString(jsonPayload));
            } else {
                report = uncachedJsonSchema.validate(JsonLoader.fromString(jsonPayload));
            }
            if (report.isSuccess()) {
                return true;
            } else {
                if (synLog.isTraceOrDebugEnabled()) {
                    String msg = "Validation of JSON failed against the given schema(s) " + cachedJsonSchemaKey.toString() + " with error : " + report + " Executing 'on-fail' sequence";
                    synLog.traceOrDebug(msg);
                    // write a warning to the service log
                    synCtx.getServiceLog().warn(msg);
                    if (synLog.isTraceTraceEnabled()) {
                        synLog.traceTrace("Failed message envelope : " + synCtx.getEnvelope());
                    }
                }
                // set error message and detail (stack trace) into the message context
                Iterator<ProcessingMessage> itrErrorMessages = report.iterator();
                // there is only one element in the report
                if (itrErrorMessages.hasNext()) {
                    ProcessingMessage processingMessage = itrErrorMessages.next();
                    String errorMessage = processingMessage.getMessage();
                    synCtx.setProperty(SynapseConstants.ERROR_MESSAGE, errorMessage);
                    synCtx.setProperty(SynapseConstants.ERROR_DETAIL, "Error while validating Json message " + errorMessage);
                }
                // invokes the "on-fail" sequence of mediator
                return invokeOnFailSequence(synCtx);
            }
        } catch (ProcessingException | IOException e) {
            String msg = "";
            if (sourcePath != null) {
                msg = " for JSONPath " + sourcePath.getExpression();
            }
            handleException("Error while validating the JSON Schema" + msg, e, synCtx);
        }
    } else {
        Source validateSrc;
        try {
            // Input source for the validation
            validateSrc = getValidationSource(synCtx, synLog);
        } catch (SynapseException e) {
            /* Catches the exception here to forward to 'on-fail' sequence.
                   The 'on-fail' sequence will get invoked when the given xpath source is not available
                   in the message.
                 */
            String errorMessage = "Error occurred while accessing source element: " + source;
            if (synLog.isTraceOrDebugEnabled()) {
                String msg = "Error occurred while accessing source element : " + source + "with error : '" + e.getMessage() + "'. Executing 'on-fail' sequence";
                synLog.traceOrDebug(msg);
                // write a warning to the service log
                synCtx.getServiceLog().warn(msg);
                if (synLog.isTraceTraceEnabled()) {
                    synLog.traceTrace("Failed message envelope : " + synCtx.getEnvelope());
                }
            }
            synCtx.setProperty(SynapseConstants.ERROR_MESSAGE, errorMessage);
            synCtx.setProperty(SynapseConstants.ERROR_DETAIL, e.getMessage());
            // invokes the "on-fail" sequence of mediator
            return invokeOnFailSequence(synCtx);
        }
        StringBuilder combinedPropertyKey = new StringBuilder();
        // flag to check if we need to initialize/re-initialize the schema
        // if any of the schemas are not loaded, or have expired, load or re-load them
        boolean reCreate = !cacheSchema || isReCreate(synCtx, combinedPropertyKey);
        /*
             * Check for the cached schema in the map and if it's available get
             * the cached schema else re initialize the schema
             */
        if (cachedSchemaMap.containsKey(combinedPropertyKey.toString())) {
            cachedSchema = cachedSchemaMap.get(combinedPropertyKey.toString());
        } else {
            reCreate = true;
        }
        // This is the reference to the DefaultHandler instance
        ValidateMediatorErrorHandler errorHandler = new ValidateMediatorErrorHandler();
        // This instance used to handle schema not cached scenarios.
        Schema uncachedSchema = null;
        // do not re-initialize schema unless required
        synchronized (validatorLock) {
            if (reCreate || cachedSchema == null) {
                factory.setErrorHandler(errorHandler);
                StreamSource[] sources = new StreamSource[schemaKeys.size()];
                StringBuilder cachedSchemaKey = new StringBuilder();
                int i = 0;
                for (Value schemaKey : schemaKeys) {
                    // Derive actual key from message context
                    String propName = schemaKey.evaluateValue(synCtx);
                    Object schemaObject = synCtx.getEntry(propName);
                    if (schemaObject == null) {
                        throw new SynapseException("No Schema is available with the key  : " + propName);
                    }
                    sources[i++] = SynapseConfigUtils.getStreamSource(schemaObject);
                    // Generating a cached schema key
                    cachedSchemaKey.append(propName);
                }
                // load the UserDefined SchemaURIResolver implementations
                try {
                    SynapseConfiguration synCfg = synCtx.getConfiguration();
                    if (synCfg.getProperty(SynapseConstants.SYNAPSE_SCHEMA_RESOLVER) != null) {
                        setUserDefinedSchemaResourceResolver(synCtx);
                    } else {
                        factory.setResourceResolver(new SchemaResourceResolver(synCtx.getConfiguration(), resourceMap));
                    }
                    if (cacheSchema) {
                        cachedSchema = factory.newSchema(sources);
                        /*
                             * Initially adds the cached schema to the map if it's
                             * not available
                             */
                        if (!cachedSchemaMap.containsKey(cachedSchemaKey.toString())) {
                            cachedSchemaMap.put(cachedSchemaKey.toString(), cachedSchema);
                        /*
                             * Removes the existing cached schema and adds the
                             * new cached schema This is used when editing a
                             * registry resource or when the cache expires
                             */
                        } else if (cachedSchemaMap.containsKey(cachedSchemaKey.toString())) {
                            cachedSchemaMap.remove(cachedSchemaKey.toString());
                            cachedSchemaMap.put(cachedSchemaKey.toString(), cachedSchema);
                        }
                    } else {
                        uncachedSchema = factory.newSchema(sources);
                    }
                } catch (SAXException e) {
                    handleException("Error creating a new schema objects for " + "schemas : " + schemaKeys.toString(), e, synCtx);
                } catch (RuntimeException e) {
                    handleException("Error creating a new schema objects for " + "schemas : " + schemaKeys.toString(), e, synCtx);
                }
                if (errorHandler.isValidationError()) {
                    // reset the errorhandler state
                    errorHandler.setValidationError(false);
                    cachedSchema = null;
                    // Removes the erroneous cached schema from the map
                    if (cachedSchemaMap.containsKey(cachedSchemaKey.toString())) {
                        cachedSchemaMap.remove(cachedSchemaKey.toString());
                    }
                    handleException("Error creating a new schema objects for schemas : " + schemaKeys.toString(), errorHandler.getSaxParseException(), synCtx);
                }
            }
        }
        // no need to synchronize, schema instances are thread-safe
        try {
            Validator validator;
            if (cacheSchema) {
                validator = cachedSchema.newValidator();
            } else {
                validator = uncachedSchema.newValidator();
            }
            validator.setErrorHandler(errorHandler);
            // perform actual validation
            validator.validate(validateSrc);
            if (errorHandler.isValidationError()) {
                if (synLog.isTraceOrDebugEnabled()) {
                    String msg = "Validation of element returned by XPath : " + source + " failed against the given schema(s) " + schemaKeys + "with error : " + errorHandler.getSaxParseException().getMessage() + " Executing 'on-fail' sequence";
                    synLog.traceOrDebug(msg);
                    // write a warning to the service log
                    synCtx.getServiceLog().warn(msg);
                    if (synLog.isTraceTraceEnabled()) {
                        synLog.traceTrace("Failed message envelope : " + synCtx.getEnvelope());
                    }
                }
                // set error message and detail (stack trace) into the message context
                synCtx.setProperty(SynapseConstants.ERROR_MESSAGE, errorHandler.getAllExceptions());
                synCtx.setProperty(SynapseConstants.ERROR_EXCEPTION, errorHandler.getSaxParseException());
                synCtx.setProperty(SynapseConstants.ERROR_DETAIL, FaultHandler.getStackTrace(errorHandler.getSaxParseException()));
                // invokes the "on-fail" sequence of the mediator
                return invokeOnFailSequence(synCtx);
            }
        } catch (SAXException e) {
            handleException("Error validating " + source + " element", e, synCtx);
        } catch (IOException e) {
            handleException("Error validating " + source + " element", e, synCtx);
        }
    }
    if (synLog.isTraceOrDebugEnabled()) {
        synLog.traceOrDebug("Validation of element returned by the XPath expression : " + source + " succeeded against the given schemas and the current message");
        synLog.traceOrDebug("End : Validate mediator");
    }
    return true;
}
Also used : SynapseException(org.apache.synapse.SynapseException) Schema(javax.xml.validation.Schema) JsonSchema(com.github.fge.jsonschema.main.JsonSchema) JsonSchema(com.github.fge.jsonschema.main.JsonSchema) JsonNode(com.fasterxml.jackson.databind.JsonNode) SynapseConfiguration(org.apache.synapse.config.SynapseConfiguration) StreamSource(javax.xml.transform.stream.StreamSource) Source(javax.xml.transform.Source) SAXException(org.xml.sax.SAXException) ProcessingReport(com.github.fge.jsonschema.core.report.ProcessingReport) SynapseLog(org.apache.synapse.SynapseLog) Axis2MessageContext(org.apache.synapse.core.axis2.Axis2MessageContext) ProcessingException(com.github.fge.jsonschema.core.exceptions.ProcessingException) InputStreamReader(java.io.InputStreamReader) ProcessingMessage(com.github.fge.jsonschema.core.report.ProcessingMessage) StreamSource(javax.xml.transform.stream.StreamSource) OMTextImpl(org.apache.axiom.om.impl.llom.OMTextImpl) IOException(java.io.IOException) SchemaResourceResolver(org.apache.synapse.util.jaxp.SchemaResourceResolver) SynapseJsonPath(org.apache.synapse.util.xpath.SynapseJsonPath) Value(org.apache.synapse.mediators.Value) Validator(javax.xml.validation.Validator)

Example 9 with JsonSchema

use of com.github.fge.jsonschema.main.JsonSchema in project carina by qaprosoft.

the class JsonValidator method validateJsonAgainstSchema.

public static void validateJsonAgainstSchema(String jsonSchema, String jsonData) {
    // create the Json nodes for schema and data
    JsonNode schemaNode;
    JsonNode data;
    try {
        schemaNode = JsonLoader.fromString(jsonSchema);
    } catch (IOException e) {
        throw new RuntimeException("Can't read schema from String: " + e.getMessage(), e);
    }
    try {
        data = JsonLoader.fromString(jsonData);
    } catch (IOException e) {
        throw new RuntimeException("Can't read json from String: " + e.getMessage(), e);
    }
    JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
    // load the schema and validate
    JsonSchema schema;
    try {
        schema = factory.getJsonSchema(schemaNode);
    } catch (ProcessingException e) {
        throw new RuntimeException("Can't process shema", e);
    }
    ProcessingReport report;
    try {
        report = schema.validate(data, true);
    } catch (ProcessingException e) {
        throw new RuntimeException("Exception during processing Json", e);
    }
    if (report.isSuccess()) {
        LOGGER.info("Validation against Json schema successfully passed");
    } else {
        StringBuffer result = new StringBuffer("Validation against Json schema failed: \n");
        Iterator<ProcessingMessage> itr = report.iterator();
        while (itr.hasNext()) {
            ProcessingMessage message = (ProcessingMessage) itr.next();
            JsonNode json = message.asJson();
            String instance = json.get("instance").get("pointer").asText();
            String errorMsg = json.get("message").asText();
            result.append("[");
            result.append(instance);
            result.append("]: ");
            result.append(errorMsg);
            result.append("\n");
        }
        throw new RuntimeException(result.toString());
    }
}
Also used : ProcessingReport(com.github.fge.jsonschema.core.report.ProcessingReport) ProcessingMessage(com.github.fge.jsonschema.core.report.ProcessingMessage) JsonSchema(com.github.fge.jsonschema.main.JsonSchema) JsonSchemaFactory(com.github.fge.jsonschema.main.JsonSchemaFactory) JsonNode(com.fasterxml.jackson.databind.JsonNode) IOException(java.io.IOException) ProcessingException(com.github.fge.jsonschema.core.exceptions.ProcessingException)

Example 10 with JsonSchema

use of com.github.fge.jsonschema.main.JsonSchema in project rest-assured by rest-assured.

the class JsonSchemaValidator method matchesSafely.

@Override
protected boolean matchesSafely(String content) {
    try {
        JsonNode contentAsJsonNode = JsonLoader.fromString(content);
        JsonSchemaFactory jsonSchemaFactory = instanceSettings.jsonSchemaFactory();
        Schema loadedSchema = loadSchema(schema, instanceSettings);
        final JsonSchema jsonSchema;
        if (loadedSchema.hasType(JsonNode.class)) {
            jsonSchema = jsonSchemaFactory.getJsonSchema(JsonNode.class.cast(loadedSchema.schema));
        } else if (loadedSchema.hasType(String.class)) {
            jsonSchema = jsonSchemaFactory.getJsonSchema(String.class.cast(loadedSchema.schema));
        } else {
            throw new RuntimeException("Internal error when loading schema from factory. Type was " + loadedSchema.schema.getClass().getName());
        }
        if (instanceSettings.shouldUseCheckedValidation()) {
            report = jsonSchema.validate(contentAsJsonNode);
        } else {
            report = jsonSchema.validateUnchecked(contentAsJsonNode);
        }
        return report.isSuccess();
    } catch (Exception e) {
        throw new JsonSchemaValidationException(e);
    }
}
Also used : JsonSchema(com.github.fge.jsonschema.main.JsonSchema) JsonSchema(com.github.fge.jsonschema.main.JsonSchema) JsonSchemaFactory(com.github.fge.jsonschema.main.JsonSchemaFactory) JsonNode(com.fasterxml.jackson.databind.JsonNode) MalformedURLException(java.net.MalformedURLException)

Aggregations

JsonSchema (com.github.fge.jsonschema.main.JsonSchema)13 JsonNode (com.fasterxml.jackson.databind.JsonNode)10 ProcessingReport (com.github.fge.jsonschema.core.report.ProcessingReport)8 JsonSchemaFactory (com.github.fge.jsonschema.main.JsonSchemaFactory)7 ProcessingException (com.github.fge.jsonschema.core.exceptions.ProcessingException)4 Extension (io.syndesis.common.model.extension.Extension)3 IOException (java.io.IOException)3 Test (org.junit.Test)3 ProcessingMessage (com.github.fge.jsonschema.core.report.ProcessingMessage)2 ObjectNode (com.fasterxml.jackson.databind.node.ObjectNode)1 ParserException (com.fasterxml.jackson.dataformat.yaml.snakeyaml.parser.ParserException)1 Swagger (io.swagger.models.Swagger)1 SwaggerParser (io.swagger.parser.SwaggerParser)1 StepDescriptor (io.syndesis.common.model.action.StepDescriptor)1 ByteArrayInputStream (java.io.ByteArrayInputStream)1 InputStream (java.io.InputStream)1 InputStreamReader (java.io.InputStreamReader)1 MalformedURLException (java.net.MalformedURLException)1 Source (javax.xml.transform.Source)1 StreamSource (javax.xml.transform.stream.StreamSource)1