cmd/validate: refactor/simplify validator code.

Update validator to reuse code distilled into the
schema package-local library.

Signed-off-by: Krisztian Litkey <[email protected]>

Author: klihub

Makefile

@@ -79,7 +79,7 @@ test-schema: bin/validate
 # dependencies
 #
 
-bin/validate: cmd/validate/validate.go
+bin/validate: cmd/validate/validate.go $(wildcard schema/*.json)
 
 # quasi-automatic dependency for bin/cdi
 bin/cdi: $(wildcard cmd/cdi/*.go cmd/cdi/cmd/*.go) $(shell \

cmd/validate/validate.go

@@ -1,7 +1,8 @@
 /*
- * From: https://github.com/opencontainers/runtime-spec/blob/643c1429d905bba70fe977bae274f367ad101e73/schema/validate.go
+ * Original code from: https://github.com/opencontainers/runtime-spec/blob/643c1429d905bba70fe977bae274f367ad101e73/schema/validate.go
  * Changes:
  *  - Output errors to stderr
+ *  - Refactored to use package-internal validation library
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,100 +20,83 @@
 package main
 
 import (
+	"flag"
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path/filepath"
-	"strings"
 
-	"github.com/xeipuuv/gojsonschema"
+	"github.com/container-orchestrated-devices/container-device-interface/schema"
 )
 
 const usage = `Validate is used to check document with specified schema.
 You can use validate in following ways:
 
    1.specify document file as an argument
-      validate <schema.json> <document.json>
+      validate --schema <schema.json> <document.json>
 
    2.pass document content through a pipe
-      cat <document.json> | validate <schema.json>
+      cat <document.json> | validate --schema <schema.json>
 
    3.input document content manually, ended with ctrl+d(or your self-defined EOF keys)
-      validate <schema.json>
+      validate --schema <schema.json>
       [INPUT DOCUMENT CONTENT HERE]
 `
 
 func main() {
-	nargs := len(os.Args[1:])
-	if nargs == 0 || nargs > 2 {
-		fmt.Printf("ERROR: invalid arguments number\n\n%s\n", usage)
-		os.Exit(1)
+	var (
+		schemaFile string
+		docFile    string
+		docData    []byte
+		err        error
+		exitCode   int
+	)
+
+	flag.Usage = func() {
+		fmt.Fprintf(flag.CommandLine.Output(), "%s\n", usage)
+		fmt.Fprintf(flag.CommandLine.Output(), "Usage of %s:\n", os.Args[0])
+		flag.PrintDefaults()
 	}
 
-	if os.Args[1] == "help" ||
-		os.Args[1] == "--help" ||
-		os.Args[1] == "-h" {
-		fmt.Printf("%s\n", usage)
-		os.Exit(1)
-	}
+	flag.StringVar(&schemaFile, "schema", "builtin", "JSON Schema to validate against")
+	flag.Parse()
 
-	schemaPath := os.Args[1]
-	if !strings.Contains(schemaPath, "://") {
-		var err error
-		schemaPath, err = formatFilePath(schemaPath)
+	if schemaFile != "" {
+		scm, err := schema.Load(schemaFile)
 		if err != nil {
-			fmt.Printf("ERROR: invalid schema-file path: %s\n", err)
+			fmt.Fprintf(os.Stderr, "failed to load schema %s: %v\n", schemaFile, err)
 			os.Exit(1)
 		}
-		schemaPath = "file://" + schemaPath
-	}
-
-	schemaLoader := gojsonschema.NewReferenceLoader(schemaPath)
-
-	var documentLoader gojsonschema.JSONLoader
-
-	if nargs > 1 {
-		documentPath, err := formatFilePath(os.Args[2])
-		if err != nil {
-			fmt.Printf("ERROR: invalid document-file path: %s\n", err)
-			os.Exit(1)
-		}
-		documentLoader = gojsonschema.NewReferenceLoader("file://" + documentPath)
+		schema.Set(scm)
+		fmt.Printf("Validating against JSON schema %s...\n", schemaFile)
 	} else {
-		documentBytes, err := ioutil.ReadAll(os.Stdin)
-		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-		documentString := string(documentBytes)
-		documentLoader = gojsonschema.NewStringLoader(documentString)
+		fmt.Printf("Validating against builtin JSON schema...\n")
 	}
 
-	result, err := gojsonschema.Validate(schemaLoader, documentLoader)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
+	docs := flag.Args()
+	if len(docs) == 0 {
+		docs = []string{"-"}
 	}
 
-	if result.Valid() {
-		fmt.Printf("The document is valid\n")
-	} else {
-		fmt.Fprintf(os.Stderr, "The document is not valid. see errors :\n")
-		for _, desc := range result.Errors() {
-			fmt.Fprintf(os.Stderr, "- %s\n", desc)
+	for _, docFile = range docs {
+		if docFile == "" || docFile == "-" {
+			docFile = "<stdin>"
+			docData, err = ioutil.ReadAll(os.Stdin)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "failed to read document data from stdin: %v\n", err)
+				os.Exit(1)
+			}
+			err = schema.ValidateData(docData)
+		} else {
+			err = schema.ValidateFile(docFile)
 		}
-		os.Exit(1)
-	}
-}
 
-func formatFilePath(path string) (string, error) {
-	if _, err := os.Stat(path); err != nil {
-		return "", err
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%s: validation failed:\n    %v\n", docFile, err)
+			exitCode = 1
+		} else {
+			fmt.Printf("%s: document is valid.\n", docFile)
+		}
 	}
 
-	absPath, err := filepath.Abs(path)
-	if err != nil {
-		return "", err
-	}
-	return absPath, nil
+	os.Exit(exitCode)
 }

schema/Makefile

@@ -1,4 +1,5 @@
 VALIDATE ?= ../bin/validate
+SCHEMA ?= schema.json
 
 test:
 	@FMT_RED=$$(tput setaf 1); \
@@ -7,7 +8,7 @@ test:
 	echo "Running Good Tests"; \
 	for FILE in $$(ls "testdata/good"); do \
 		FILE_PATH="testdata/good/$${FILE}"; \
-		if $(VALIDATE) "schema.json" "$${FILE_PATH}" > /dev/null ; then \
+		if $(VALIDATE) --schema "$(SCHEMA)" "$${FILE_PATH}" > /dev/null ; then \
 			printf '%s[OK]%s %s\n' "$${FMT_BLUE}" "$${FMT_CLEAR}" "$${FILE_PATH}"; \
 		else \
 			printf '%s[KO]%s %s\n' "$${FMT_RED}" "$${FMT_CLEAR}" "$${FILE_PATH}"; \
@@ -17,7 +18,7 @@ test:
 	echo "Running Bad Tests"; \
 	for FILE in $$(ls "testdata/bad"); do \
 		FILE_PATH="testdata/bad/$${FILE}"; \
-		if $(VALIDATE) "schema.json" "$${FILE_PATH}" > /dev/null ; then \
+		if $(VALIDATE) --schema "$(SCHEMA)" "$${FILE_PATH}" > /dev/null ; then \
 			printf '%s[KO]%s %s\n' "$${FMT_RED}" "$${FMT_CLEAR}" "$${FILE_PATH}"; \
 			exit 1; \
 		else \