Switches to Imposter for mock config generation.

Uses path hints to guess availability path.

Author: outofcoffee

cmd/mock.go

@@ -17,17 +17,17 @@ limitations under the License.
 package cmd
 
 import (
-	"fmt"
 	"gatehill.io/imposter/engine"
 	"gatehill.io/imposter/engine/docker"
+	imposterfileutil "gatehill.io/imposter/fileutil"
+	"gatehill.io/imposter/impostermodel"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"opendeps.org/opendeps/fileutil"
 	"opendeps.org/opendeps/model"
 	"os"
 	"os/signal"
 	"path/filepath"
-	"strings"
 	"syscall"
 )
 
@@ -53,8 +53,8 @@ by this tool.`,
 		logrus.Debugf("reading opendeps manifest: %v\n", manifestPath)
 		manifest := model.Parse(manifestPath)
 
-		bundleManifest(stagingDir, manifestPath)
-		generateMockConfig(stagingDir, manifestPath, manifest)
+		bundleManifest(stagingDir, manifestPath, flagForceOverwrite)
+		bundleSpecs(stagingDir, manifestPath, manifest, flagForceOverwrite)
 
 		mockEngine := docker.BuildEngine(stagingDir, engine.StartOptions{
 			Port:            8080,
@@ -68,50 +68,51 @@ by this tool.`,
 	},
 }
 
-func bundleManifest(stagingDir string, manifestPath string) {
+func init() {
+	rootCmd.AddCommand(mockCmd)
+}
+
+func bundleManifest(stagingDir string, manifestPath string, forceOverwrite bool) {
 	logrus.Debugf("bundling manifest: %v", manifestPath)
 	err := fileutil.CopyContent(manifestPath, filepath.Join(stagingDir, "opendeps.yaml"))
 	if err != nil {
 		logrus.Fatal(err)
 	}
-	writeManifestOpenApiSpec(stagingDir)
-}
 
-func init() {
-	rootCmd.AddCommand(mockCmd)
+	specFileName := "opendeps-openapi-gen.yaml"
+	writeManifestSpec(stagingDir, specFileName)
+
+	resources := []impostermodel.Resource{
+		{
+			Path:   "/.well-known/opendeps/manifest.yaml",
+			Method: "GET",
+			Response: &impostermodel.ResponseConfig{
+				StaticFile: "opendeps.yaml",
+			},
+		},
+	}
+	writeMockConfig(filepath.Join(stagingDir, specFileName), resources, forceOverwrite)
 }
 
-func generateMockConfig(stagingDir string, specFile string, manifest *model.OpenDeps) string {
+func bundleSpecs(stagingDir string, manifestPath string, manifest *model.OpenDeps, forceOverwrite bool) string {
 	for _, dependency := range manifest.Dependencies {
-		openapiNormalisedPath := makeAbsoluteRelativeToFile(dependency.Spec, specFile)
-		logrus.Debugf("bundling openapi spec: %v\n", openapiNormalisedPath)
+		specNormalisedPath := fileutil.MakeAbsoluteRelativeToFile(dependency.Spec, manifestPath)
+		logrus.Debugf("bundling openapi spec: %v\n", specNormalisedPath)
 
-		openapiFilename := filepath.Base(openapiNormalisedPath)
-		openapiDestFile := filepath.Join(stagingDir, openapiFilename)
-		err := fileutil.CopyContent(openapiNormalisedPath, openapiDestFile)
+		specDestPath := filepath.Join(stagingDir, filepath.Base(specNormalisedPath))
+		err := fileutil.CopyContent(specNormalisedPath, specDestPath)
 		if err != nil {
 			panic(err)
 		}
 
-		writeMockConfig(stagingDir, openapiFilename)
+		writeMockConfig(specDestPath, nil, forceOverwrite)
 	}
 	return stagingDir
 }
 
-func makeAbsoluteRelativeToFile(filePath string, specFile string) string {
-	specDir := filepath.Dir(specFile)
-
-	var openapiNormalisedPath string
-	if strings.HasPrefix(filePath, "./") {
-		openapiNormalisedPath = filepath.Join(specDir, strings.TrimPrefix(filePath, "."))
-	} else {
-		openapiNormalisedPath = filePath
-	}
-	return openapiNormalisedPath
-}
-
-func writeManifestOpenApiSpec(configDir string) {
-	specFileName := "opendeps-openapi-gen.yaml"
+// writeManifestSpec creates an OpenAPI spec describing the well known endpoint
+// that serves the manifest.
+func writeManifestSpec(configDir string, specFileName string) {
 	specFile, err := os.Create(filepath.Join(configDir, specFileName))
 	if err != nil {
 		panic(err)
@@ -141,40 +142,21 @@ paths:
 	if err != nil {
 		panic(err)
 	}
-
-	err = specFile.Sync()
-	if err != nil {
-		panic(err)
-	}
-
-	writeMockConfig(configDir, specFileName)
 }
 
-func writeMockConfig(configDir string, openapiFilename string) {
-	configFile, err := os.Create(filepath.Join(configDir, fmt.Sprintf("%v-config.yaml", openapiFilename)))
+func writeMockConfig(specFilePath string, resources []impostermodel.Resource, forceOverwrite bool) {
+	configFilePath := imposterfileutil.GenerateFilePathAdjacentToFile(specFilePath, "-config.yaml", forceOverwrite)
+	configFile, err := os.Create(configFilePath)
 	if err != nil {
 		panic(err)
 	}
 	defer configFile.Close()
 
-	config := fmt.Sprintf(`---
-plugin: openapi
-specFile: "%v"
-
-resources:
-- path: /.well-known/opendeps/manifest.yaml
-  method: GET
-  response:
-    staticFile: opendeps.yaml
-    template: true
-`, openapiFilename)
-
-	_, err = configFile.WriteString(config)
-	if err != nil {
-		panic(err)
-	}
+	config := impostermodel.GenerateConfig(specFilePath, resources, impostermodel.ConfigGenerationOptions{
+		ScriptEngine: impostermodel.ScriptEngineNone,
+	})
 
-	err = configFile.Sync()
+	_, err = configFile.Write(config)
 	if err != nil {
 		panic(err)
 	}

cmd/scaffold.go

@@ -91,9 +91,7 @@ func scaffoldManifest(specDir string, forceOverwrite bool) {
 		}
 	}
 
-	manifestFileName := fileutil.GenerateFilenameAdjacentToFile(specDir, filepath.Join(specDir, "opendeps"), ".yaml", forceOverwrite)
-	manifestPath := filepath.Join(specDir, manifestFileName)
-
+	manifestPath := fileutil.GenerateFilePathAdjacentToFile(filepath.Join(specDir, "opendeps"), ".yaml", forceOverwrite)
 	file, err := os.Create(manifestPath)
 	if err != nil {
 		logrus.Fatalf("error creating opendeps manifest file: %v: %v", manifestPath, err)
@@ -110,10 +108,29 @@ func scaffoldManifest(specDir string, forceOverwrite bool) {
 }
 
 func determineAvailabilityPath(spec *openapi.PartialModel) string {
+	var getPaths []string
 	for path, operations := range spec.Paths {
 		if _, found := operations["get"]; found {
-			return path
+			getPaths = append(getPaths, path)
+		}
+	}
+	if len(getPaths) == 1 {
+		return getPaths[0]
+	} else {
+		for _, path := range getPaths {
+			for _, pathHint := range getAvailabilityPathHints() {
+				if path == pathHint {
+					return path
+				}
+			}
 		}
 	}
 	return "/"
 }
+
+func getAvailabilityPathHints() []string {
+	return []string{
+		"/healthz",
+		"/system/status",
+	}
+}

cmd/test.go

@@ -92,7 +92,7 @@ func testDependencies(manifestPath string) (successful int, tested int) {
 	return available, len(manifest.Dependencies)
 }
 
-func testDependency(specFile string, depName string, dep model.Dependency) error {
+func testDependency(manifestPath string, depName string, dep model.Dependency) error {
 	if "" != dep.Availability.Security {
 		logrus.Warnf("security configuration for availability endpoints is not supported\n")
 	}
@@ -104,7 +104,7 @@ func testDependency(specFile string, depName string, dep model.Dependency) error
 
 	} else if "" != dep.Availability.Path {
 		// relative - use openapi spec servers as base path
-		basePath, err := determineBasePath(specFile, depName, dep)
+		basePath, err := determineBasePath(manifestPath, depName, dep)
 		if err != nil {
 			return err
 		}
@@ -128,24 +128,24 @@ func testDependency(specFile string, depName string, dep model.Dependency) error
 	return nil
 }
 
-func determineBasePath(specFile string, depName string, dependency model.Dependency) (string, error) {
+func determineBasePath(manifestPath string, depName string, dependency model.Dependency) (string, error) {
 	if serverUrl, found := flagServers[depName]; found {
 		logrus.Debugf("determined server [%v] from overrides", serverUrl)
 		return serverUrl, nil
 
 	} else {
-		openapiNormalisedPath := makeAbsoluteRelativeToFile(dependency.Spec, specFile)
-		openapiSpec, err := openapi.Parse(openapiNormalisedPath)
+		specNormalisedPath := fileutil.MakeAbsoluteRelativeToFile(dependency.Spec, manifestPath)
+		openapiSpec, err := openapi.Parse(specNormalisedPath)
 		if err != nil {
-			return "", fmt.Errorf("failed to parse spec [%v]: %v\n", openapiNormalisedPath, err)
+			return "", fmt.Errorf("failed to parse spec [%v]: %v\n", specNormalisedPath, err)
 		}
 		if len(openapiSpec.Servers) == 0 {
-			return "", fmt.Errorf("no servers found in spec [%v]\n", openapiNormalisedPath)
+			return "", fmt.Errorf("no servers found in spec [%v]\n", specNormalisedPath)
 		} else if len(openapiSpec.Servers) > 1 {
-			logrus.Warnf("more than 1 server found in spec [%v] - using first\n", openapiNormalisedPath)
+			logrus.Warnf("more than 1 server found in spec [%v] - using first\n", specNormalisedPath)
 		}
 		serverUrl := openapiSpec.Servers[0].Url
-		logrus.Debugf("determined server [%v] from openapi spec [%v]", serverUrl, openapiNormalisedPath)
+		logrus.Debugf("determined server [%v] from openapi spec [%v]", serverUrl, specNormalisedPath)
 		return serverUrl, nil
 	}
 }

fileutil/fileutil.go

@@ -24,6 +24,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strings"
 )
 
@@ -97,10 +98,6 @@ func writeToFile(source io.Reader, dest string) error {
 		return fmt.Errorf("error : %s", err.Error())
 	}
 
-	err = destFile.Sync()
-	if err != nil {
-		return fmt.Errorf("error : %s", err.Error())
-	}
 	return nil
 }
 
@@ -115,3 +112,15 @@ func fetchFile(source string) (io.ReadCloser, error) {
 	}
 	return os.Open(normalisedPath)
 }
+
+func MakeAbsoluteRelativeToFile(inputPath string, relativeToPath string) string {
+	specDir := filepath.Dir(relativeToPath)
+
+	var normalisedPath string
+	if strings.HasPrefix(inputPath, "./") {
+		normalisedPath = filepath.Join(specDir, strings.TrimPrefix(inputPath, "."))
+	} else {
+		normalisedPath = inputPath
+	}
+	return normalisedPath
+}

fileutil/specfile.go fileutil/manifest.gofileutil/specfile.go renamed to fileutil/manifest.go

@@ -35,10 +35,10 @@ func getDefaultSearchFilenames() []string {
 // If args is not empty, the path is made absolute, followed by
 // a search for well-known filenames, or a fully qualified
 // file path if specified.
-func FindManifestFile(args []string) (specFile string, err error) {
+func FindManifestFile(args []string) (manifestPath string, err error) {
 	if len(args) == 0 {
 		wd, _ := os.Getwd()
-		return findSpecInDir(wd)
+		return findManifestInDir(wd)
 	} else {
 		absPath, _ := filepath.Abs(args[0])
 		fileInfo, err := os.Stat(absPath)
@@ -50,13 +50,13 @@ func FindManifestFile(args []string) (specFile string, err error) {
 			}
 		}
 		if fileInfo.IsDir() {
-			return findSpecInDir(absPath)
+			return findManifestInDir(absPath)
 		}
 		return absPath, nil
 	}
 }
 
-func findSpecInDir(dir string) (specFile string, err error) {
+func findManifestInDir(dir string) (manifestPath string, err error) {
 	for _, defaultSearchFilename := range getDefaultSearchFilenames() {
 		searchFilePath := filepath.Join(dir, defaultSearchFilename)
 		if _, err := os.Stat(searchFilePath); err != nil {

go.mod

@@ -2,10 +2,10 @@ module opendeps.org/opendeps
 
 go 1.17
 
-replace gatehill.io/imposter => github.com/gatehill/imposter-cli v0.4.2
+replace gatehill.io/imposter => github.com/gatehill/imposter-cli v0.4.5
 
 require (
-	gatehill.io/imposter v0.4.2
+	gatehill.io/imposter v0.4.5
 	github.com/fsnotify/fsnotify v1.5.1 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect

go.sum

@@ -279,8 +279,8 @@ github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWp
 github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU=
 github.com/fullsailor/pkcs7 v0.0.0-20190404230743-d7302db945fa/go.mod h1:KnogPXtdwXqoenmZCw6S+25EAm2MkxbG0deNDu4cbSA=
 github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY=
-github.com/gatehill/imposter-cli v0.4.2 h1:yCyVRA+qJZ/tdD0VmOKle2TW2UzMDt8G6oC8m3yIrh0=
-github.com/gatehill/imposter-cli v0.4.2/go.mod h1:1cvFX7e8yvBhldJKnIMFV276eLsbtO6LmrHGx4bN+IQ=
+github.com/gatehill/imposter-cli v0.4.5 h1:F7WifoC/oZql390jtJS5KM1H1atSBePvet0ht3PCZWs=
+github.com/gatehill/imposter-cli v0.4.5/go.mod h1:1cvFX7e8yvBhldJKnIMFV276eLsbtO6LmrHGx4bN+IQ=
 github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=

model/parser.go

@@ -22,8 +22,8 @@ import (
 	"io/ioutil"
 )
 
-func Parse(specFile string) *OpenDeps {
-	raw, err := ioutil.ReadFile(specFile)
+func Parse(manifestPath string) *OpenDeps {
+	raw, err := ioutil.ReadFile(manifestPath)
 	if err != nil {
 		logrus.Fatalln(err)
 	}