docker

type AccessInfo struct {

	// image is the OCI compatible descriptor for the location of the image. Typically it
	// is in the form `repo/name`, where repo is a host name (perhaps with a port), and
	// name may also contain / use to identify subdivision on the host.
	Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
	// tag is the OCI compatible tag that the resulting data will be stored at within
	// the repository defined by image.
	Tag string `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"`
	// auth indicates how to authenticate with the repository defined by image.
	//
	// Types that are assignable to Auth:
	//
	//	*AccessInfo_Header
	//	*AccessInfo_Encoded
	//	*AccessInfo_UserPass_
	Auth isAccessInfo_Auth `protobuf_oneof:"auth"`
	// insecure indicates if the repository defined by image should be access via http or https.
	Insecure bool `protobuf:"varint,5,opt,name=insecure,proto3" json:"insecure,omitempty"`
	// contains filtered or unexported fields
}

type AccessInfo_Encoded struct {
	// encoded is the docker standard encoded authentication data. This is base64 encoded
	// json that contains username and passwword fields that are used for authentication.
	Encoded string `protobuf:"bytes,4,opt,name=encoded,proto3,oneof"`
}

type AccessInfo_Header struct {
	// header is the value of the Authentication header that is sent to the repository.
	// This allows for repositories that use bearer tokens or other sorts of authentication.
	Header string `protobuf:"bytes,3,opt,name=header,proto3,oneof"`
}

type AccessInfo_UserPass struct {

	// The username to authenticate against the registry with
	Username string `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	// The password assocated with the above username
	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	// contains filtered or unexported fields
}

type AccessInfo_UserPass_ struct {
	// user_pass specifies a username and password to use to authenticate with the registry.
	// The registry plugin will transform this information to the proper format as needed.
	UserPass *AccessInfo_UserPass `protobuf:"bytes,6,opt,name=user_pass,json=userPass,proto3,oneof"`
}

type Auth struct {
	Hostname      string `hcl:"hostname,optional"`
	Username      string `hcl:"username,optional"`
	Password      string `hcl:"password,optional"`
	Email         string `hcl:"email,optional"`
	Auth          string `hcl:"auth,optional"`
	ServerAddress string `hcl:"serverAddress,optional"`
	IdentityToken string `hcl:"identityToken,optional"`
	RegistryToken string `hcl:"registryToken,optional"`
}

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

type BuilderConfig struct {
	// Control whether or not to inject the entrypoint binary into the resulting image
	DisableCEB bool `hcl:"disable_entrypoint,optional"`

	// Controls whether or not the image should be build with buildkit or docker v1
	UseBuildKit bool `hcl:"buildkit,optional"`

	// The name/path to the Dockerfile if it is not the root of the project
	Dockerfile string `hcl:"dockerfile,optional"`

	// Controls the passing of platform flag variables
	Platform string `hcl:"platform,optional"`

	// Controls the passing of build time variables
	BuildArgs map[string]*string `hcl:"build_args,optional"`

	// Controls the passing of build context
	Context string `hcl:"context,optional"`

	// Authenticates to private registry
	Auth *Auth `hcl:"auth,block"`

	// Controls the passing of the target stage
	Target string `hcl:"target,optional"`

	// Disable the build cache
	NoCache bool `hcl:"no_cache,optional"`
}

type ClientConfig struct {
	// Host to use when connecting to Docker
	// This can be used to connect to remote Docker instances
	Host string `hcl:"host,optional"`

	// Path to load the certificates for the Docker Engine
	CertPath string `hcl:"cert_path,optional"`

	// Docker API version to use for connection
	APIVersion string `hcl:"api_version,optional"`
}

type Config struct {
	// Image is the name of the image plus tag that the image will be pushed as.
	Image string `hcl:"image,attr"`

	// Tag is the tag to apply to the image.
	Tag string `hcl:"tag,attr"`

	// Local if true will not push this image to a remote registry.
	Local bool `hcl:"local,optional"`

	// Authenticates to private registry
	Auth *Auth `hcl:"auth,block"`

	// The docker specific encoded authentication string to use to talk to the registry.
	EncodedAuth string `hcl:"encoded_auth,optional"`

	// Insecure indicates if the registry should be accessed via http rather than https
	Insecure bool `hcl:"insecure,optional"`

	// Username is the username to use for authentication on the registry.
	Username string `hcl:"username,optional"`

	// Password is the authentication information assocated with username.
	Password string `hcl:"password,optional"`
}

type Deployment struct {
	Id            string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name          string         `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Container     string         `protobuf:"bytes,3,opt,name=container,proto3" json:"container,omitempty"`
	ResourceState *opaqueany.Any `protobuf:"bytes,4,opt,name=resource_state,json=resourceState,proto3" json:"resource_state,omitempty"`
	// contains filtered or unexported fields
}

type Image struct {
	Image        string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
	Tag          string `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"`
	Architecture string `protobuf:"bytes,6,opt,name=architecture,proto3" json:"architecture,omitempty"`
	// location is where this image is currently. This can be used to
	// determine if the image is pulled or not based on this proto rather
	// than environment inspection.
	//
	// If this is not set, it will be assumed that the image is in a local
	// Docker daemon registry for backwards compatiblity reasons.
	//
	// Types that are assignable to Location:
	//
	//	*Image_Registry
	//	*Image_Docker
	//	*Image_UnusedImg
	Location isImage_Location `protobuf_oneof:"location"`
	// contains filtered or unexported fields
}

type Image_Docker struct {
	// docker is set if the image is in a local Docker daemon registry.
	Docker *emptypb.Empty `protobuf:"bytes,4,opt,name=docker,proto3,oneof"`
}

type Image_Registry struct {
	// registry is set if the image is in a remote registry. This value
	// might mean the image is local, too, but we never formally "pulled"
	// it so we aren't sure. The image should be treated as remote.
	Registry *Image_RegistryLocation `protobuf:"bytes,3,opt,name=registry,proto3,oneof"`
}

type Image_RegistryLocation struct {

	// waypoint_generated indicates that the Image was generated by a process
	// that resulted in the fully built image being already stored in the
	// registry. This is commonly done in ODR for pack and docker-build.
	WaypointGenerated bool `protobuf:"varint,1,opt,name=waypoint_generated,json=waypointGenerated,proto3" json:"waypoint_generated,omitempty"`
	// contains filtered or unexported fields
}

type Image_UnusedImg struct {
	// Waypoint 0.6 and earlier supported "img" as a Dockerless builder.
	// We removed this in 0.7, hence we prefix this now with "unused". We
	// keep the field around so we can detect old clients sending it and
	// show an error. Do not set this.
	UnusedImg *emptypb.Empty `protobuf:"bytes,5,opt,name=unused_img,json=unusedImg,proto3,oneof"`
}

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

type PlatformConfig struct {
	// A list of folders to mount to the container.
	Binds []string `hcl:"binds,optional"`

	// ClientConfig allow the user to specify the connection to the Docker
	// engine. By default we try to load this from env vars:
	// DOCKER_HOST to set the url to the docker server.
	// DOCKER_API_VERSION to set the version of the API to reach, leave empty for latest.
	// DOCKER_CERT_PATH to load the TLS certificates from.
	// DOCKER_TLS_VERIFY to enable or disable TLS verification, off by default.
	ClientConfig *ClientConfig `hcl:"client_config,block"`

	// The command to run in the container. This is an array of arguments
	// that are executed directly. These are not executed in the context of
	// a shell. If you want to use a shell, add that to this command manually.
	Command []string `hcl:"command,optional"`

	// Force pull the image from the remote repository
	ForcePull bool `hcl:"force_pull,optional"`

	// Authenticates to private registry
	Auth *Auth `hcl:"auth,block"`

	// A map of key/value pairs, stored in docker as a string. Each key/value pair must
	// be unique. Validiation occurs at the docker layer, not in Waypoint. Label
	// keys are alphanumeric strings which may contain periods (.) and hyphens (-).
	// See the docker docs for more info: https://docs.docker.com/config/labels-custom-metadata/
	Labels map[string]string `hcl:"labels,optional"`

	// An array of strings with network names to connect the container to
	Networks []string `hcl:"networks,optional"`

	// A map of resources to configure the container with such as memory and cpu
	// limits.
	Resources map[string]string `hcl:"resources,optional"`

	// A path to a directory that will be created for the service to store
	// temporary data.
	ScratchSpace string `hcl:"scratch_path,optional"`

	// Environment variables that are meant to configure the application in a static
	// way. This might be control an image that has mulitple modes of operation,
	// selected via environment variable. Most configuration should use the waypoint
	// config commands.
	StaticEnvVars map[string]string `hcl:"static_environment,optional"`

	// Additional ports the application is listening on to expose on the container
	ExtraPorts []uint `hcl:"extra_ports,optional"`

	// Port that your service is running on within the actual container.
	// Defaults to port 3000.
	// TODO Evaluate if this should remain as a default 3000, should be a required field,
	// or default to another port.
	ServicePort uint `hcl:"service_port,optional"`
}

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

type Release struct {
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	// contains filtered or unexported fields
}

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

type Resource_Container struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

type Resource_Network struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

type TaskInfo struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

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

type TaskLauncherConfig struct {
	// A list of folders to mount to the container.
	Binds []string `hcl:"binds,optional"`

	// ClientConfig allow the user to specify the connection to the Docker
	// engine. By default we try to load this from env vars:
	// DOCKER_HOST to set the url to the docker server.
	// DOCKER_API_VERSION to set the version of the API to reach, leave empty for latest.
	// DOCKER_CERT_PATH to load the TLS certificates from.
	// DOCKER_TLS_VERIFY to enable or disable TLS verification, off by default.
	ClientConfig *ClientConfig `hcl:"client_config,block"`

	// Force pull the image from the remote repository
	ForcePull bool `hcl:"force_pull,optional"`

	// A map of key/value pairs, stored in docker as a string. Each key/value pair must
	// be unique. Validiation occurs at the docker layer, not in Waypoint. Label
	// keys are alphanumeric strings which may contain periods (.) and hyphens (-).
	// See the docker docs for more info: https://docs.docker.com/config/labels-custom-metadata/
	Labels map[string]string `hcl:"labels,optional"`

	// An array of strings with network names to connect the container to
	Networks []string `hcl:"networks,optional"`

	// Resources configures the resource constraints such as cpu and memory for the
	// created containers.
	Resources *TaskResources `hcl:"resources,block"`

	// Environment variables that are meant to configure the application in a static
	// way. This might be start an image in a specific mode,
	// selected via environment variable. Most configuration should use the waypoint
	// config commands.
	StaticEnvVars map[string]string `hcl:"static_environment,optional"`

	// Keep containers around after the task finishes. This allows the ability to debug
	// the containers and see their logs with the native docker tools.
	DebugContainers bool `hcl:"debug_containers,optional"`
}

type TaskResources struct {
	// How many CPU shares to allocate to each task
	CpuShares int64 `hcl:"cpu,optional"`

	// How much memory to allocate to each task
	MemoryLimit string `hcl:"memory,optional"`
}