provider

package module
v0.0.0-...-df31936 Latest Latest
Warning

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

 Go to latest Published: Mar 26, 2026 License: Apache-2.0 Imports: 25 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Provider 

func Provider() p.Provider

Provider data and resources

func RunProvider 

func RunProvider(ctx context.Context, providerName, Version string) error

RunProvider runs the pulumi provider and adds its resources

Types

type Backend 

type Backend struct {
	Address   string `pulumi:"address"`
	Namespace string `pulumi:"namespace"`
	Password  string `pulumi:"password"`
}

Backend is a zos backend

func (*Backend) Annotate 

func (b *Backend) Annotate(a infer.Annotator)

type Config 

type Config struct {
	Mnemonic      string   `pulumi:"mnemonic,optional"  provider:"secret"`
	Network       string   `pulumi:"network,optional"`
	KeyType       string   `pulumi:"key_type,optional"`
	SubstrateURLs []string `pulumi:"substrate_url,optional"`
	RelayURLs     []string `pulumi:"relay_url,optional"`
	ProxyURLs     []string `pulumi:"proxy_url,optional"`
	GraphqlURLs   []string `pulumi:"graphql_url,optional"`
	RmbTimeout    string   `pulumi:"rmb_timeout,optional"`

	TFPluginClient deployer.TFPluginClient
}

Config struct holds the configuration fields for the provider

func (*Config) Annotate 

func (c *Config) Annotate(a infer.Annotator)

Annotate sets description and default values for configs

func (*Config) Configure 

func (c *Config) Configure(ctx context.Context) error

Configure checks configuration for the provider

type Deployment 

type Deployment struct{}

Deployment controlling struct

func (*Deployment) Check 

func (*Deployment) Check(
	ctx context.Context,
	name string, oldInputs,
	newInputs property.Map,
) (DeploymentArgs, []p.CheckFailure, error)

Check validates the Deployment

func (*Deployment) Create 

func (*Deployment) Create(
	ctx context.Context,
	req infer.CreateRequest[DeploymentArgs],
) (infer.CreateResponse[DeploymentState], error)

Create creates a deployment

func (*Deployment) Delete 

func (*Deployment) Delete(ctx context.Context, req infer.DeleteRequest[DeploymentState]) error

Delete deletes a deployment resource

func (*Deployment) Read 

func (*Deployment) Read(ctx context.Context, req infer.ReadRequest[DeploymentArgs, DeploymentState]) (infer.ReadResponse[DeploymentArgs, DeploymentState], error)

Read gets the state of the deployment resource

func (*Deployment) Update 

func (*Deployment) Update(
	ctx context.Context,
	req infer.UpdateRequest[DeploymentArgs, DeploymentState],
) (infer.UpdateResponse[DeploymentState], error)

Update updates the arguments of the deployment resource

type DeploymentArgs 

type DeploymentArgs struct {
	NodeID           interface{} `pulumi:"node_id"`
	Name             string      `pulumi:"name"`
	NetworkName      string      `pulumi:"network_name,optional"`
	SolutionType     string      `pulumi:"solution_type,optional"`
	SolutionProvider int64       `pulumi:"solution_provider,optional"`
	Disks            []Disk      `pulumi:"disks,optional"`
	ZdbsInputs       []ZDBInput  `pulumi:"zdbs,optional"`
	VmsInputs        []VMInput   `pulumi:"vms,optional"`
	QSFSInputs       []QSFSInput `pulumi:"qsfs,optional"`
}

DeploymentArgs is defining what arguments it accepts

func (*DeploymentArgs) Annotate 

func (d *DeploymentArgs) Annotate(a infer.Annotator)

type DeploymentState 

type DeploymentState struct {
	DeploymentArgs

	NodeDeploymentID map[string]int64 `pulumi:"node_deployment_id"`
	ContractID       int64            `pulumi:"contract_id"`
	IPrange          string           `pulumi:"ip_range"`
	ZdbsComputed     []ZDBComputed    `pulumi:"zdbs_computed"`
	VmsComputed      []VMComputed     `pulumi:"vms_computed"`
	QsfsComputed     []QSFSComputed   `pulumi:"qsfs_computed"`
}

DeploymentState is describing the fields that exist on the created resource

func (*DeploymentState) Annotate 

func (d *DeploymentState) Annotate(a infer.Annotator)

type Disk 

type Disk struct {
	Name        string `pulumi:"name"`
	Size        int    `pulumi:"size"`
	Description string `pulumi:"description,optional"`
}

Disk represents the disk struct

func (*Disk) Annotate 

func (d *Disk) Annotate(a infer.Annotator)

type GatewayFQDN 

type GatewayFQDN struct{}

GatewayFQDN controlling struct

func (*GatewayFQDN) Check 

func (*GatewayFQDN) Check(
	ctx context.Context,
	name string, oldInputs,
	newInputs property.Map,
) (GatewayFQDNArgs, []p.CheckFailure, error)

Check validates fqdn gateway data

func (*GatewayFQDN) Create 

func (*GatewayFQDN) Create(
	ctx context.Context,
	req infer.CreateRequest[GatewayFQDNArgs],
) (infer.CreateResponse[GatewayFQDNState], error)

Create creates a fqdn gateway

func (*GatewayFQDN) Delete 

func (*GatewayFQDN) Delete(ctx context.Context, req infer.DeleteRequest[GatewayFQDNState]) error

Delete deletes a fqdn gateway resource

func (*GatewayFQDN) Read 

func (*GatewayFQDN) Read(ctx context.Context, req infer.ReadRequest[GatewayFQDNArgs, GatewayFQDNState]) (infer.ReadResponse[GatewayFQDNArgs, GatewayFQDNState], error)

Read gets the state of the fqdn gateway resource

func (*GatewayFQDN) Update 

func (*GatewayFQDN) Update(
	ctx context.Context,
	req infer.UpdateRequest[GatewayFQDNArgs, GatewayFQDNState],
) (infer.UpdateResponse[GatewayFQDNState], error)

Update updates the arguments of a fqdn gateway resource

type GatewayFQDNArgs 

type GatewayFQDNArgs struct {
	NodeID         interface{}   `pulumi:"node_id"`
	Name           string        `pulumi:"name"`
	FQDN           string        `pulumi:"fqdn"`
	Backends       []zos.Backend `pulumi:"backends"`
	NetworkName    string        `pulumi:"network_name,optional"`
	Description    string        `pulumi:"description,optional"`
	TLSPassthrough bool          `pulumi:"tls_pass_through,optional"`
	SolutionType   string        `pulumi:"solution_type,optional"`
}

GatewayFQDNArgs is defining what arguments it accepts

func (*GatewayFQDNArgs) Annotate 

func (g *GatewayFQDNArgs) Annotate(a infer.Annotator)

type GatewayFQDNState 

type GatewayFQDNState struct {
	GatewayFQDNArgs

	ContractID       int64            `pulumi:"contract_id"`
	NodeDeploymentID map[string]int64 `pulumi:"node_deployment_id"`
}

GatewayFQDNState is describing the fields that exist on the fqdn gateway resource

func (*GatewayFQDNState) Annotate 

func (g *GatewayFQDNState) Annotate(a infer.Annotator)

type GatewayName 

type GatewayName struct{}

GatewayName controlling struct

func (*GatewayName) Check 

func (*GatewayName) Check(
	ctx context.Context,
	name string, oldInputs,
	newInputs property.Map,
) (GatewayNameArgs, []p.CheckFailure, error)

Check validates name gateway data

func (*GatewayName) Create 

func (*GatewayName) Create(
	ctx context.Context,
	req infer.CreateRequest[GatewayNameArgs],
) (infer.CreateResponse[GatewayNameState], error)

Create creates GatewayName and deploy it

func (*GatewayName) Delete 

func (*GatewayName) Delete(ctx context.Context, req infer.DeleteRequest[GatewayNameState]) error

Delete deletes the GatewayName resource

func (*GatewayName) Read 

func (*GatewayName) Read(ctx context.Context, req infer.ReadRequest[GatewayNameArgs, GatewayNameState]) (infer.ReadResponse[GatewayNameArgs, GatewayNameState], error)

Read gets the state of the GatewayName resource

func (*GatewayName) Update 

func (*GatewayName) Update(
	ctx context.Context,
	req infer.UpdateRequest[GatewayNameArgs, GatewayNameState],
) (infer.UpdateResponse[GatewayNameState], error)

Update updates the GatewayName resource

type GatewayNameArgs 

type GatewayNameArgs struct {
	Name           string      `pulumi:"name"`
	NodeID         interface{} `pulumi:"node_id"`
	Backends       []string    `pulumi:"backends"`
	TLSPassthrough bool        `pulumi:"tls_passthrough,optional"`
	NetworkName    string      `pulumi:"network_name,optional"`
	Description    string      `pulumi:"description,optional"`
	SolutionType   string      `pulumi:"solution_type,optional"`
}

GatewayNameArgs is defining what arguments it accepts

func (*GatewayNameArgs) Annotate 

func (g *GatewayNameArgs) Annotate(a infer.Annotator)

type GatewayNameState 

type GatewayNameState struct {
	GatewayNameArgs

	NodeDeploymentID map[string]int64 `pulumi:"node_deployment_id"`
	FQDN             string           `pulumi:"fqdn"`
	NameContractID   int64            `pulumi:"name_contract_id"`
	ContractID       int64            `pulumi:"contract_id"`
}

GatewayNameState is describing the fields that exist on the created resource.

func (*GatewayNameState) Annotate 

func (g *GatewayNameState) Annotate(a infer.Annotator)

type Group 

type Group struct {
	Backends []Backend `pulumi:"backends,optional"`
}

Group is a zos group

func (*Group) Annotate 

func (g *Group) Annotate(a infer.Annotator)

type K8sNodeInput 

type K8sNodeInput struct {
	Name           string      `pulumi:"name"`
	Description    string      `pulumi:"description,optional"`
	NetworkName    string      `pulumi:"network_name"`
	NodeID         interface{} `pulumi:"node_id"`
	DiskSize       int         `pulumi:"disk_size"`
	Flist          string      `pulumi:"flist,optional"`
	EntryPoint     string      `pulumi:"entry_point,optional"`
	FlistChecksum  string      `pulumi:"flist_checksum,optional"`
	CPU            int         `pulumi:"cpu"`
	Memory         int         `pulumi:"memory"`
	PublicIP       bool        `pulumi:"public_ip,optional"`
	PublicIP6      bool        `pulumi:"public_ip6,optional"`
	Planetary      bool        `pulumi:"planetary,optional"`
	Mycelium       bool        `pulumi:"mycelium,optional"`
	MyceliumIPSeed string      `pulumi:"mycelium_ip_seed,optional"`
}

K8sNodeInput struct of input data

func (*K8sNodeInput) Annotate 

func (k *K8sNodeInput) Annotate(a infer.Annotator)

type Kubernetes 

type Kubernetes struct{}

Kubernetes controlling struct

func (*Kubernetes) Check 

func (*Kubernetes) Check(
	ctx context.Context,
	name string, oldInputs,
	newInputs property.Map,
) (KubernetesArgs, []p.CheckFailure, error)

Check validates kubernetes data

func (*Kubernetes) Create 

func (*Kubernetes) Create(
	ctx context.Context,
	req infer.CreateRequest[KubernetesArgs],
) (infer.CreateResponse[KubernetesState], error)

Create creates Kubernetes cluster and deploy it

func (*Kubernetes) Delete 

func (*Kubernetes) Delete(ctx context.Context, req infer.DeleteRequest[KubernetesState]) error

Delete deletes the Kubernetes resource

func (*Kubernetes) Read 

func (*Kubernetes) Read(ctx context.Context, req infer.ReadRequest[KubernetesArgs, KubernetesState]) (infer.ReadResponse[KubernetesArgs, KubernetesState], error)

Read get the state of the Kubernetes resource

func (*Kubernetes) Update 

func (*Kubernetes) Update(
	ctx context.Context,
	req infer.UpdateRequest[KubernetesArgs, KubernetesState],
) (infer.UpdateResponse[KubernetesState], error)

Update updates the arguments of the Kubernetes resource

type KubernetesArgs 

type KubernetesArgs struct {
	Master        K8sNodeInput   `pulumi:"master"`
	Workers       []K8sNodeInput `pulumi:"workers"`
	Token         string         `pulumi:"token"`
	NetworkName   string         `pulumi:"network_name"`
	SolutionType  string         `pulumi:"solution_type,optional"`
	SSHKey        string         `pulumi:"ssh_key,optional"`
	Flist         string         `pulumi:"flist,optional"`
	EntryPoint    string         `pulumi:"entry_point,optional"`
	FlistChecksum string         `pulumi:"flist_checksum,optional"`
}

KubernetesArgs is defining what arguments it accepts

func (*KubernetesArgs) Annotate 

func (k *KubernetesArgs) Annotate(a infer.Annotator)

type KubernetesState 

type KubernetesState struct {
	KubernetesArgs

	MasterComputed   VMComputed            `pulumi:"master_computed"`
	WorkersComputed  map[string]VMComputed `pulumi:"workers_computed"`
	NodesIPRange     map[string]string     `pulumi:"nodes_ip_range"`
	NodeDeploymentID map[string]int64      `pulumi:"node_deployment_id"`
}

KubernetesState is describing the fields that exist on the created resource.

func (*KubernetesState) Annotate 

func (k *KubernetesState) Annotate(a infer.Annotator)

type Metadata 

type Metadata struct {
	EncryptionKey       string    `pulumi:"encryption_key"`
	Prefix              string    `pulumi:"prefix"`
	EncryptionAlgorithm string    `pulumi:"encryption_algorithm,optional"`
	Type                string    `pulumi:"type,optional"`
	Backends            []Backend `pulumi:"backends,optional"`
}

Metadata for QSFS

func (*Metadata) Annotate 

func (m *Metadata) Annotate(a infer.Annotator)

type Mount 

type Mount struct {
	Name       string `pulumi:"name"`
	MountPoint string `pulumi:"mount_point"`
}

Mount represents mounting of disks

func (*Mount) Annotate 

func (m *Mount) Annotate(a infer.Annotator)

type Network 

type Network struct{}

Network controlling struct

func (*Network) Check 

func (*Network) Check(
	ctx context.Context,
	name string, oldInputs,
	newInputs property.Map,
) (NetworkArgs, []p.CheckFailure, error)

Check validates the network

func (*Network) Create 

func (*Network) Create(ctx context.Context, req infer.CreateRequest[NetworkArgs]) (infer.CreateResponse[NetworkState], error)

Create creates network and deploy it

func (*Network) Delete 

func (*Network) Delete(ctx context.Context, req infer.DeleteRequest[NetworkState]) error

Delete deletes the network resource

func (*Network) Read 

func (*Network) Read(ctx context.Context, req infer.ReadRequest[NetworkArgs, NetworkState]) (infer.ReadResponse[NetworkArgs, NetworkState], error)

Read get the state of the network resource

func (*Network) Update 

func (*Network) Update(
	ctx context.Context,
	req infer.UpdateRequest[NetworkArgs, NetworkState],
) (infer.UpdateResponse[NetworkState], error)

Update updates the arguments of the network resource

type NetworkArgs 

type NetworkArgs struct {
	Name         string            `pulumi:"name"`
	Description  string            `pulumi:"description"`
	Nodes        []interface{}     `pulumi:"nodes"`
	IPRange      string            `pulumi:"ip_range"`
	AddWGAccess  bool              `pulumi:"add_wg_access,optional"`
	SolutionType string            `pulumi:"solution_type,optional"`
	MyceliumKeys map[string]string `pulumi:"mycelium_keys,optional"`
	Mycelium     bool              `pulumi:"mycelium,optional"`
}

NetworkArgs is defining what arguments it accepts

func (*NetworkArgs) Annotate 

func (n *NetworkArgs) Annotate(a infer.Annotator)

type NetworkState 

type NetworkState struct {
	NetworkArgs

	MyceliumKeys     map[string]string `pulumi:"mycelium_keys,optional"`
	AccessWGConfig   string            `pulumi:"access_wg_config"`
	ExternalIP       string            `pulumi:"external_ip"`
	ExternalSK       string            `pulumi:"external_sk"`
	PublicNodeID     int32             `pulumi:"public_node_id"`
	NodesIPRange     map[string]string `pulumi:"nodes_ip_range"`
	NodeDeploymentID map[string]int64  `pulumi:"node_deployment_id"`
}

NetworkState is describing the fields that exist on the created resource.

func (*NetworkState) Annotate 

func (n *NetworkState) Annotate(a infer.Annotator)

type QSFSComputed 

type QSFSComputed struct {
	MetricsEndpoint string `pulumi:"metrics_endpoint"`
}

QSFSComputed is the QSFS Computed struct

func (*QSFSComputed) Annotate 

func (q *QSFSComputed) Annotate(a infer.Annotator)

type QSFSInput 

type QSFSInput struct {
	Name                 string   `pulumi:"name"`
	Description          string   `pulumi:"description,optional"`
	Cache                int      `pulumi:"cache"`
	MinimalShards        int32    `pulumi:"minimal_shards"`
	ExpectedShards       int32    `pulumi:"expected_shards"`
	RedundantGroups      int32    `pulumi:"redundant_groups"`
	RedundantNodes       int32    `pulumi:"redundant_nodes"`
	MaxZDBDataDirSize    int32    `pulumi:"max_zdb_data_dir_size"`
	EncryptionAlgorithm  string   `pulumi:"encryption_algorithm,optional"`
	EncryptionKey        string   `pulumi:"encryption_key"`
	CompressionAlgorithm string   `pulumi:"compression_algorithm,optional"`
	Metadata             Metadata `pulumi:"metadata"`
	Groups               []Group  `pulumi:"groups"`
}

QSFSInput is the QSFS input struct

func (*QSFSInput) Annotate 

func (q *QSFSInput) Annotate(a infer.Annotator)

type Scheduler 

type Scheduler struct{}

Scheduler controlling struct

func (*Scheduler) Create 

func (*Scheduler) Create(
	ctx context.Context,
	req infer.CreateRequest[SchedulerArgs],
) (infer.CreateResponse[SchedulerState], error)

Create creates scheduler

func (*Scheduler) Delete 

func (*Scheduler) Delete(ctx context.Context, req infer.DeleteRequest[SchedulerState]) error

Delete deletes the scheduler resource

func (*Scheduler) Read 

func (*Scheduler) Read(ctx context.Context, req infer.ReadRequest[SchedulerArgs, SchedulerState]) (infer.ReadResponse[SchedulerArgs, SchedulerState], error)

Read get the state of the scheduler resource

func (*Scheduler) Update 

func (*Scheduler) Update(
	ctx context.Context,
	req infer.UpdateRequest[SchedulerArgs, SchedulerState],
) (infer.UpdateResponse[SchedulerState], error)

Update updates the arguments of the scheduler resource

type SchedulerArgs 

type SchedulerArgs struct {
	MRU               int64   `pulumi:"mru,optional"`
	HRU               int64   `pulumi:"hru,optional"`
	SRU               int64   `pulumi:"sru,optional"`
	Country           string  `pulumi:"country,optional"`
	City              string  `pulumi:"city,optional"`
	FarmName          string  `pulumi:"farm_name,optional"`
	FarmIDs           []int64 `pulumi:"farm_ids,optional"`
	FreeIPs           int64   `pulumi:"free_ips,optional"`
	Ygg               bool    `pulumi:"ygg,optional"`
	Wireguard         bool    `pulumi:"wireguard,optional"`
	IPv4              bool    `pulumi:"ipv4,optional"`
	IPv6              bool    `pulumi:"ipv6,optional"`
	Domain            bool    `pulumi:"domain,optional"`
	Dedicated         bool    `pulumi:"dedicated,optional"`
	Rented            bool    `pulumi:"rented,optional"`
	Rentable          bool    `pulumi:"rentable,optional"`
	NodeID            int64   `pulumi:"node_id,optional"`
	TwinID            int64   `pulumi:"twin_id,optional"`
	CertificationType string  `pulumi:"certification_type,optional"`
	HasGPU            bool    `pulumi:"has_gpu,optional"`
	GpuDeviceID       string  `pulumi:"gpu_device_id,optional"`
	GpuDeviceName     string  `pulumi:"gpu_device_name,optional"`
	GpuVendorID       string  `pulumi:"gpu_vendor_id,optional"`
	GpuVendorName     string  `pulumi:"gpu_vendor_name,optional"`
	GpuAvailable      bool    `pulumi:"gpu_available,optional"`
}

SchedulerArgs is defining what arguments it accepts

type SchedulerState 

type SchedulerState struct {
	SchedulerArgs

	Nodes []int32 `pulumi:"nodes"`
}

SchedulerState is describing the fields that exist on the created resource.

type VMComputed 

type VMComputed struct {
	MyceliumIPSeed string `pulumi:"mycelium_ip_seed"`
	ComputedIP     string `pulumi:"computed_ip"`
	ComputedIP6    string `pulumi:"computed_ip6"`
	PlanetaryIP    string `pulumi:"planetary_ip"`
	MyceliumIP     string `pulumi:"mycelium_ip"`
	ConsoleURL     string `pulumi:"console_url"`
	IP             string `pulumi:"ip,optional"`
}

VMComputed is a virtual machine computed struct

func (*VMComputed) Annotate 

func (v *VMComputed) Annotate(a infer.Annotator)

type VMInput 

type VMInput struct {
	Name           string            `pulumi:"name"`
	NodeID         interface{}       `pulumi:"node_id"`
	Flist          string            `pulumi:"flist"`
	FlistChecksum  string            `pulumi:"flist_checksum,optional"`
	NetworkName    string            `pulumi:"network_name"`
	CPU            int               `pulumi:"cpu"`
	Memory         int               `pulumi:"memory"`
	PublicIP       bool              `pulumi:"public_ip,optional"`
	PublicIP6      bool              `pulumi:"public_ip6,optional"`
	Planetary      bool              `pulumi:"planetary,optional"`
	Mycelium       bool              `pulumi:"mycelium,optional"`
	MyceliumIPSeed string            `pulumi:"mycelium_ip_seed,optional"`
	Description    string            `pulumi:"description,optional"`
	GPUs           []zos.GPU         `pulumi:"gpus,optional"`
	RootfsSize     int               `pulumi:"rootfs_size,optional"`
	EntryPoint     string            `pulumi:"entrypoint,optional"`
	Mounts         []Mount           `pulumi:"mounts,optional"`
	Zlogs          []Zlog            `pulumi:"zlogs,optional"`
	EnvVars        map[string]string `pulumi:"env_vars,optional"`
}

VMInput is a virtual machine inputs struct

func (*VMInput) Annotate 

func (v *VMInput) Annotate(a infer.Annotator)

type ZDBComputed 

type ZDBComputed struct {
	IPs       []string `pulumi:"ips"`
	Port      int32    `pulumi:"port"`
	Namespace string   `pulumi:"namespace"`
}

ZDBComputed is the ZDB workload Computed struct

func (*ZDBComputed) Annotate 

func (z *ZDBComputed) Annotate(a infer.Annotator)

type ZDBInput 

type ZDBInput struct {
	Name        string `pulumi:"name"`
	Size        int    `pulumi:"size"`
	Password    string `pulumi:"password"`
	Public      bool   `pulumi:"public,optional"`
	Description string `pulumi:"description,optional"`
	Mode        string `pulumi:"mode,optional"`
}

ZDBInput is the ZDB workload inputs struct

func (*ZDBInput) Annotate 

func (z *ZDBInput) Annotate(a infer.Annotator)

type Zlog 

type Zlog struct {
	Zmachine string `pulumi:"zmachine"`
	Output   string `pulumi:"output"`
}

Zlog logger struct

func (*Zlog) Annotate 

func (z *Zlog) Annotate(a infer.Annotator)

Source Files

View all Source files

Directories

Path Synopsis
cmd
pulumi-gen-threefold command
pulumi-resource-threefold command
pkg
version

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.