jsonnext

README

jsonnext

Extension libraries for go-jsonnet. The name jsonnext is a contraction of jsonnet and ext.

Documentation for this module is on pkg.go.dev.

Importer

foxygo.at/jsonnext.Importer is a jsonnet.Importer implementation that can import from the local filesystem and from https network sources. Normal paths, absolute and relative, are imported from the local filesystem. Paths starting with a double-slash (//) are imported as https URLs with an implicit https: prefix. For example, the path //github.com/grafana/grafonnet-lib/raw/master/grafonnet/grafana.libsonnet refers to the file grafana.libsonnet on the master branch of the grafana/grafonnet-lib repository on GitHub (using the "raw" path to retrieve the contents of the file instead of the GitHub web page for the file).

The Importer has a SearchPath of type []string that can be populated directly or by using the AppendSearchFromEnv() method. The method takes the name of an environment variable, splits it on the OS-specific ListSeparator and appends the elements to the existing search path.

The default Fetcher for the importer is the default http.Client. It can be replaced with any type that implements the Get method of http.Client. Most likely it will be overridden with a http.Client that has been constructed with a non-default configuration.

The importer maintains a cache of results as is required by the jsonnet.Importer interface description. Positive and negative results are cached and returned on subsequent calls to import the same path. Errors retrieving a path are not cached and are returned as an error results from the Import method.

Documentation

Index

• type Importer
  • func (i *Importer) AppendSearchFromEnv(envvar string)
  • func (i *Importer) Import(source, imp string) (jsonnet.Contents, string, error)
• type URLFetcher

Types

type Importer

type Importer struct {
	// SearchPath is an ordered slice of paths (network or local filesystem)
	// that is prepended to the imported filename if the filename is not
	// found. Searching stops when it is found.
	SearchPath []string

	// Fetcher is the URLFetcher used to fetch paths. The default is a
	// http.Client that has a `file:` scheme handler.
	Fetcher URLFetcher
	// contains filtered or unexported fields
}

Importer implements the jsonnet.Importer interface, allowing jsonnet code to be imported via https in addition to local files. Filenames starting with a double-slash (`//`) are fetched via HTTPS. Otherwise the path is treated as a local filesystem path.

Once an import path is successfully fetched, either with data or a definitive not found result, that result is cached for the lifetime of the Importer. This is a requirement of the jsonnet.Importer interface so it is not possible for the same import statement from different files to result in different content. If an Importer is shared across multiple jsonnet.VM instances, the the cache will be shared too. There is no cache expiry logic.

func (*Importer) AppendSearchFromEnv

func (i *Importer) AppendSearchFromEnv(envvar string)

AppendSearchFromEnv appends a list of search paths specified in the given environment variable to the search path list. The elements of the path in the variable are separated by the filepath.SplitList() delimiter.

func (*Importer) Import

func (i *Importer) Import(source, imp string) (jsonnet.Contents, string, error)

Import loads imp from a file or a network location. If imp is a relative path, search for it relative to the directory of source and the search path elements. If the import found, return its contents and the absolute location where it was found. If it was not found, or there was an error reading the content, return the error.

Import will cache the result and return it the next time that path is requested.

This method is defined in the jsonnet.Importer interface:

https://godoc.org/github.com/google/go-jsonnet#Importer

type URLFetcher

type URLFetcher interface {
	Get(url string) (*http.Response, error)
}

A URLFetcher retreives a URL returning a http.Response or an error. It is defined such that http.Client implements it, but allows a different implementation or a custom-configured http.Client to be provided to the Importer.