compute

package
v1.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 11, 2021 License: Apache-2.0 Imports: 42 Imported by: 0

Documentation

Overview

Package compute contains commands to manage Compute@Edge packages.

Index

Constants

View Source 
const IgnoreFilePath = ".fastlyignore"

IgnoreFilePath is the filepath name of the Fastly ignore file.

Variables

View Source 
var InstallDir = func() string {
	if dir, err := os.UserConfigDir(); err == nil {
		return filepath.Join(dir, "fastly")
	}
	if dir, err := os.UserHomeDir(); err == nil {
		return filepath.Join(dir, ".fastly")
	}
	panic("unable to deduce user config dir or user home dir")
}()

InstallDir represents the directory where the Viceroy binary should be installed.

NOTE: This is a package level variable as it makes testing the behaviour of the package easier because the test code can replace the value when running the test suite.

View Source 
var PackageSizeLimit int64 = 50000000

PackageSizeLimit describes the package size limit in bytes (currently 50mb) https://docs.fastly.com/products/compute-at-edge-billing-and-resource-limits#resource-limits

Functions

func CreatePackageArchive 

func CreatePackageArchive(files []string, destination string) error

CreatePackageArchive packages build artifacts as a Fastly package, which must be a GZipped Tar archive such as: package-name.tar.gz.

Due to a behavior of archiver.Archive() which recursively writes all files in a provided directory to the archive we first copy our input files to a temporary directory to ensure only the specified files are included and not any in the directory which may be ignored.

func FileNameWithoutExtension 

func FileNameWithoutExtension(filename string) string

FileNameWithoutExtension returns a filename with its extension stripped.

func GetCrateVersionFromMetadata 

func GetCrateVersionFromMetadata(metadata CargoMetadata, crate string) (*semver.Version, error)

GetCrateVersionFromMetadata searches for a crate inside a CargoMetadata tree and returns the crates version as a semver.Version.

func GetIgnoredFiles 

func GetIgnoredFiles(filePath string) (files map[string]bool, err error)

GetIgnoredFiles reads the .fastlyignore file line-by-line and expands the glob pattern into a map containing all files it matches. If no ignore file is present it returns an empty map.

func GetLatestCrateVersion 

func GetLatestCrateVersion(client api.HTTPClient, name string) (*semver.Version, error)

GetLatestCrateVersion fetches all versions of a given Rust crate from the crates.io HTTP API and returns the latest valid semver version.

func GetNonIgnoredFiles 

func GetNonIgnoredFiles(base string, ignoredFiles map[string]bool) ([]string, error)

GetNonIgnoredFiles walks a filepath and returns all files don't exist in the provided ignore files map.

Types

type AssemblyScript 

type AssemblyScript struct {
	// contains filtered or unexported fields
}

AssemblyScript implements a Toolchain for the AssemblyScript language.

func NewAssemblyScript 

func NewAssemblyScript(timeout int) *AssemblyScript

NewAssemblyScript constructs a new AssemblyScript.

func (AssemblyScript) Build 

func (a AssemblyScript) Build(out io.Writer, verbose bool) error

Build implements the Toolchain interface and attempts to compile the package AssemblyScript source to a Wasm binary.

func (AssemblyScript) Initialize 

func (a AssemblyScript) Initialize(out io.Writer) error

Initialize implements the Toolchain interface and initializes a newly cloned package by installing required dependencies.

func (AssemblyScript) Verify 

func (a AssemblyScript) Verify(out io.Writer) error

Verify implements the Toolchain interface and verifies whether the AssemblyScript language toolchain is correctly configured on the host.

type BuildCommand 

type BuildCommand struct {
	cmd.Base

	// NOTE: these are public so that the "publish" composite command can set the
	// values appropriately before calling the Exec() function.
	IncludeSrc       bool
	Lang             string
	Manifest         manifest.Data
	PackageName      string
	SkipVerification bool
	Timeout          int
	// contains filtered or unexported fields
}

BuildCommand produces a deployable artifact from files on the local disk.

func NewBuildCommand 

func NewBuildCommand(parent cmd.Registerer, client api.HTTPClient, globals *config.Data, data manifest.Data) *BuildCommand

NewBuildCommand returns a usable command registered under the parent.

func (*BuildCommand) Exec 

func (c *BuildCommand) Exec(in io.Reader, out io.Writer) (err error)

Exec implements the command interface.

type CargoCrateVersion 

type CargoCrateVersion struct {
	Version string `json:"num"`
}

CargoCrateVersion models a Cargo crate version returned by the crates.io API.

type CargoCrateVersions 

type CargoCrateVersions struct {
	Versions []CargoCrateVersion `json:"versions"`
}

CargoCrateVersions models a Cargo crate version returned by the crates.io API.

type CargoManifest 

type CargoManifest struct {
	Package CargoPackage
}

CargoManifest models the package configuration properties of a Rust Cargo manifest which we are interested in and are read from the Cargo.toml manifest file within the $PWD of the package.

func (*CargoManifest) Read 

func (m *CargoManifest) Read(fpath string) error

Read the contents of the Cargo.toml manifest from filename.

type CargoMetadata 

type CargoMetadata struct {
	Package         []CargoPackage `json:"packages"`
	TargetDirectory string         `json:"target_directory"`
}

CargoMetadata models information about the workspace members and resolved dependencies of the current package via `cargo metadata` command output.

func (*CargoMetadata) Read 

func (m *CargoMetadata) Read() error

Read the contents of the Cargo.lock file from filename.

type CargoPackage 

type CargoPackage struct {
	Name         string         `toml:"name" json:"name"`
	Version      string         `toml:"version" json:"version"`
	Dependencies []CargoPackage `toml:"-" json:"dependencies"`
}

CargoPackage models the package configuration properties of a Rust Cargo package which we are interested in and is embedded within CargoManifest and CargoLock.

type DeployCommand 

type DeployCommand struct {
	cmd.Base

	// NOTE: these are public so that the "publish" composite command can set the
	// values appropriately before calling the Exec() function.
	AcceptDefaults bool
	Comment        cmd.OptionalString
	Domain         string
	Manifest       manifest.Data
	Path           string
	ServiceVersion cmd.OptionalServiceVersion
}

DeployCommand deploys an artifact previously produced by build.

func NewDeployCommand 

func NewDeployCommand(parent cmd.Registerer, client api.HTTPClient, globals *config.Data, data manifest.Data) *DeployCommand

NewDeployCommand returns a usable command registered under the parent.

func (*DeployCommand) Exec 

func (c *DeployCommand) Exec(in io.Reader, out io.Writer) (err error)

Exec implements the command interface.

type InitCommand 

type InitCommand struct {
	cmd.Base
	// contains filtered or unexported fields
}

InitCommand initializes a Compute@Edge project package on the local machine.

func NewInitCommand 

func NewInitCommand(parent cmd.Registerer, client api.HTTPClient, globals *config.Data, data manifest.Data) *InitCommand

NewInitCommand returns a usable command registered under the parent.

func (*InitCommand) Exec 

func (c *InitCommand) Exec(in io.Reader, out io.Writer) (err error)

Exec implements the command interface.

type JavaScript 

type JavaScript struct {
	// contains filtered or unexported fields
}

JavaScript implements a Toolchain for the JavaScript language.

func NewJavaScript 

func NewJavaScript(timeout int) *JavaScript

NewJavaScript constructs a new JavaScript.

func (JavaScript) Build 

func (a JavaScript) Build(out io.Writer, verbose bool) error

Build implements the Toolchain interface and attempts to compile the package JavaScript source to a Wasm binary.

func (JavaScript) Initialize 

func (a JavaScript) Initialize(out io.Writer) error

Initialize implements the Toolchain interface and initializes a newly cloned package by installing required dependencies.

func (JavaScript) Verify 

func (a JavaScript) Verify(out io.Writer) error

Verify implements the Toolchain interface and verifies whether the JavaScript language toolchain is correctly configured on the host.

type Language 

type Language struct {
	Name            string
	DisplayName     string
	StarterKits     []config.StarterKit
	SourceDirectory string
	IncludeFiles    []string

	Toolchain
}

Language models a Compute@Edge source language.

func NewLanguage 

func NewLanguage(options *LanguageOptions) *Language

NewLanguage constructs a new Language from a LangaugeOptions.

func NewLanguages added in v0.41.0 

func NewLanguages(kits config.StarterKitLanguages, c api.HTTPClient, d *config.Data) []*Language

NewLanguages returns a list of supported programming languages.

NOTE: The 'timeout' value zero is passed into each New<Language> call as it's only useful during the `compute build` phase and is expected to be provided by the user via a flag on the build command.

type LanguageOptions 

type LanguageOptions struct {
	Name            string
	DisplayName     string
	StarterKits     []config.StarterKit
	SourceDirectory string
	IncludeFiles    []string
	Toolchain       Toolchain
}

LanguageOptions models configuration options for a Language.

type PackCommand 

type PackCommand struct {
	cmd.Base
	// contains filtered or unexported fields
}

PackCommand takes a .wasm and builds the required tar/gzip package ready to be uploaded.

func NewPackCommand 

func NewPackCommand(parent cmd.Registerer, globals *config.Data, data manifest.Data) *PackCommand

NewPackCommand returns a usable command registered under the parent.

func (*PackCommand) Exec 

func (c *PackCommand) Exec(in io.Reader, out io.Writer) (err error)

Exec implements the command interface.

type PublishCommand 

type PublishCommand struct {
	cmd.Base
	// contains filtered or unexported fields
}

PublishCommand produces and deploys an artifact from files on the local disk.

func NewPublishCommand 

func NewPublishCommand(parent cmd.Registerer, globals *config.Data, build *BuildCommand, deploy *DeployCommand, data manifest.Data) *PublishCommand

NewPublishCommand returns a usable command registered under the parent.

func (*PublishCommand) Exec 

func (c *PublishCommand) Exec(in io.Reader, out io.Writer) (err error)

Exec implements the command interface.

NOTE: unlike other non-aggregate commands that initialize a new text.Progress type for displaying progress information to the user, we don't use that in this command because the nested commands overlap the output in non-deterministic ways. It's best to leave those nested commands to handle the progress indicator.

type RootCommand 

type RootCommand struct {
	cmd.Base
}

RootCommand is the parent command for all subcommands in this package. It should be installed under the primary root command.

func NewRootCommand 

func NewRootCommand(parent cmd.Registerer, globals *config.Data) *RootCommand

NewRootCommand returns a new command registered in the parent.

func (*RootCommand) Exec 

func (c *RootCommand) Exec(in io.Reader, out io.Writer) error

Exec implements the command interface.

type Rust 

type Rust struct {
	// contains filtered or unexported fields
}

Rust implements a Toolchain for the Rust language.

func NewRust 

func NewRust(client api.HTTPClient, config *config.Data, timeout int) *Rust

NewRust constructs a new Rust.

func (*Rust) Build 

func (r *Rust) Build(out io.Writer, verbose bool) error

Build implements the Toolchain interface and attempts to compile the package Rust source to a Wasm binary.

func (Rust) IncludeFiles 

func (r Rust) IncludeFiles() []string

IncludeFiles implements the Toolchain interface and returns a list of additional files to include in the package archive for Rust packages.

func (Rust) Initialize 

func (r Rust) Initialize(out io.Writer) error

Initialize implements the Toolchain interface and initializes a newly cloned package. It is a noop for Rust as the Cargo toolchain handles these steps.

func (Rust) SourceDirectory 

func (r Rust) SourceDirectory() string

SourceDirectory implements the Toolchain interface and returns the source directory for Rust packages.

func (*Rust) Verify 

func (r *Rust) Verify(out io.Writer) (err error)

Verify implments the Toolchain interface and verifies whether the Rust language toolchain is correctly configured on the host.

NOTE: Steps for validation are:

1. Validate `rustc` installed. 2. Validate `rustc --version` meets the constraint. 3. Validate `wasm32-wasi` target is added to the relevant toolchain. 4. Validate `cargo` is installed. 5. Validate `fastly-sys` crate version. 6. Validate `fastly` crate version (optional upgrade suggestion).

type ServeCommand 

type ServeCommand struct {
	cmd.Base
	// contains filtered or unexported fields
}

ServeCommand produces and runs an artifact from files on the local disk.

func NewServeCommand 

func NewServeCommand(parent cmd.Registerer, globals *config.Data, build *BuildCommand, viceroyVersioner update.Versioner, data manifest.Data) *ServeCommand

NewServeCommand returns a usable command registered under the parent.

func (*ServeCommand) Build added in v1.1.0 

func (c *ServeCommand) Build(in io.Reader, out io.Writer) error

Build constructs and executes the build logic.

func (*ServeCommand) Exec 

func (c *ServeCommand) Exec(in io.Reader, out io.Writer) (err error)

Exec implements the command interface.

type Toolchain 

type Toolchain interface {
	Initialize(out io.Writer) error
	Verify(out io.Writer) error
	Build(out io.Writer, verbose bool) error
}

Toolchain abstracts a Compute@Edge source language toolchain.

type UpdateCommand 

type UpdateCommand struct {
	cmd.Base
	// contains filtered or unexported fields
}

UpdateCommand calls the Fastly API to update packages.

func NewUpdateCommand 

func NewUpdateCommand(parent cmd.Registerer, client api.HTTPClient, globals *config.Data, data manifest.Data) *UpdateCommand

NewUpdateCommand returns a usable command registered under the parent.

func (*UpdateCommand) Exec 

func (c *UpdateCommand) Exec(in io.Reader, out io.Writer) (err error)

Exec invokes the application logic for the command.

type ValidateCommand 

type ValidateCommand struct {
	cmd.Base
	// contains filtered or unexported fields
}

ValidateCommand validates a package archive.

func NewValidateCommand 

func NewValidateCommand(parent cmd.Registerer, globals *config.Data) *ValidateCommand

NewValidateCommand returns a usable command registered under the parent.

func (*ValidateCommand) Exec 

func (c *ValidateCommand) Exec(in io.Reader, out io.Writer) error

Exec implements the command interface.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.