client

package
v0.2.2 Latest Latest
Warning

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

 Go to latest Published: Jan 15, 2025 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Overview

Package client provides a simple RMB interface to work with the node.

Requirements

1. A msgbusd instance must be running on the node. this client uses RMB (message bus) to send messages to nodes, and get the repspons. 2. A valid ed25519 key pair. this key is used to sign deployments and MUST be the same key used to configure the local twin on substrate.

Simple deployment

create an instance from the default rmb client. ``` cl, err := rmb.Default() 

if err != nil {
	panic(err)
}

``` then create an instance of the node client ``` node := client.NewNodeClient(NodeTwinID, cl) ``` define your deployment object ``` 

dl := gridtypes.Deployment{
	Version: Version,
	TwinID:  Twin, //LocalTwin,
	// this contract id must match the one on substrate
	Workloads: []gridtypes.Workload{
		network(), // network workload definition
		zmount(), // zmount workload definition
		publicip(), // public ip definition
		zmachine(), // zmachine definition
	},
	SignatureRequirement: gridtypes.SignatureRequirement{
		WeightRequired: 1,
		Requests: []gridtypes.SignatureRequest{
			{
				TwinID: Twin,
				Weight: 1,
			},
		},
	},
}

``` compute hash ``` hash, err := dl.ChallengeHash() 

if err != nil {
	panic("failed to create hash")
}

fmt.Printf("Hash: %x\n", hash) ``` create the contract and ge the contract id then “ dl.ContractID = 11 // from substrate ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) defer cancel() err = node.DeploymentDeploy(ctx, dl) 

if err != nil {
	panic(err)
}

```

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Counters 

type Counters struct {
	// Total system capacity
	Total gridtypes.Capacity `json:"total"`
	// Used capacity this include user + system resources
	Used gridtypes.Capacity `json:"used"`
	// System resource reserved by zos
	System gridtypes.Capacity `json:"system"`
	// Users statistics by zos
	Users UsersCounters `json:"users"`
}

Counters (statistics) of the node

type ExitDevice 

type ExitDevice struct {
	// IsSingle is set to true if br-pub
	// is connected to zos bridge
	IsSingle bool `json:"is_single"`
	// IsDual is set to true if br-pub is
	// connected to a physical nic
	IsDual bool `json:"is_dual"`
	// AsDualInterface is set to the physical
	// interface name if IsDual is true
	AsDualInterface string `json:"dual_interface"`
}

type GPU 

type GPU struct {
	ID       string `json:"id"`
	Vendor   string `json:"vendor"`
	Device   string `json:"device"`
	Contract uint64 `json:"contract"`
}

GPU information

type Interface 

type Interface struct {
	IPs []string `json:"ips"`
	Mac string   `json:"mac"`
}

type NodeClient 

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

NodeClient struct

func NewNodeClient 

func NewNodeClient(nodeTwin uint32, bus rmb.Client) *NodeClient

NewNodeClient creates a new node RMB client. This client then can be used to communicate with the node over RMB.

func (*NodeClient) Counters 

func (n *NodeClient) Counters(ctx context.Context) (counters Counters, err error)

Counters returns some node statistics. Including total and available cpu, memory, storage, etc...

func (*NodeClient) DeploymentChanges 

func (n *NodeClient) DeploymentChanges(ctx context.Context, contractID uint64) (changes []gridtypes.Workload, err error)

DeploymentGet gets a deployment via contract ID

func (*NodeClient) DeploymentDelete 

func (n *NodeClient) DeploymentDelete(ctx context.Context, contractID uint64) error

DeploymentDelete deletes a deployment, the node will make sure to decomission all deployments and set all workloads to deleted. A call to Get after delete is valid

func (*NodeClient) DeploymentDeploy 

func (n *NodeClient) DeploymentDeploy(ctx context.Context, dl gridtypes.Deployment) error

DeploymentDeploy sends the deployment to the node for processing.

func (*NodeClient) DeploymentGet 

func (n *NodeClient) DeploymentGet(ctx context.Context, contractID uint64) (dl gridtypes.Deployment, err error)

DeploymentGet gets a deployment via contract ID

func (*NodeClient) DeploymentList 

func (n *NodeClient) DeploymentList(ctx context.Context) (dls []gridtypes.Deployment, err error)

DeploymentList gets all deployments for a twin

func (*NodeClient) DeploymentUpdate 

func (n *NodeClient) DeploymentUpdate(ctx context.Context, dl gridtypes.Deployment) error

DeploymentUpdate update the given deployment. deployment must be a valid update for a deployment that has been already created via DeploymentDeploy

func (*NodeClient) GPUs 

func (n *NodeClient) GPUs(ctx context.Context) (gpus []GPU, err error)

func (*NodeClient) HasPublicIPv6 

func (n *NodeClient) HasPublicIPv6(ctx context.Context) (bool, error)

func (*NodeClient) NetworkGetPublicConfig 

func (n *NodeClient) NetworkGetPublicConfig(ctx context.Context) (cfg pkg.PublicConfig, err error)

NetworkGetPublicConfig returns the current public node network configuration. A node with a public config can be used as an access node for wireguard.

func (*NodeClient) NetworkGetPublicExitDevice 

func (n *NodeClient) NetworkGetPublicExitDevice(ctx context.Context) (exit ExitDevice, err error)

NetworkGetPublicExitDevice gets the current dual nic setup of the node.

func (*NodeClient) NetworkListAllInterfaces 

func (n *NodeClient) NetworkListAllInterfaces(ctx context.Context) (result map[string]Interface, err error)

NetworkListAllInterfaces return all physical devices on a node

func (*NodeClient) NetworkListInterfaces 

func (n *NodeClient) NetworkListInterfaces(ctx context.Context) (result map[string][]net.IP, err error)

func (*NodeClient) NetworkListPrivateIPs 

func (n *NodeClient) NetworkListPrivateIPs(ctx context.Context, networkName string) ([]string, error)

NetworkListPrivateIPs list private ips reserved for a network

func (*NodeClient) NetworkListPublicIPs 

func (n *NodeClient) NetworkListPublicIPs(ctx context.Context) ([]string, error)

NetworkListPublicIPs list taken public IPs on the node

func (*NodeClient) NetworkListWGPorts 

func (n *NodeClient) NetworkListWGPorts(ctx context.Context) ([]uint16, error)

NetworkListWGPorts return a list of all "taken" ports on the node. A new deployment should be careful to use a free port for its network setup.

func (*NodeClient) NetworkSetPublicExitDevice 

func (n *NodeClient) NetworkSetPublicExitDevice(ctx context.Context, iface string) error

NetworkSetPublicExitDevice select which physical interface to use as an exit device setting `iface` to `zos` will then make node run in a single nic setup.

func (*NodeClient) Pools 

func (n *NodeClient) Pools(ctx context.Context) (pools []pkg.PoolMetrics, err error)

Pools returns statistics of separate pools

func (*NodeClient) SystemDMI 

func (n *NodeClient) SystemDMI(ctx context.Context) (result dmi.DMI, err error)

func (*NodeClient) SystemDiagnostics 

func (n *NodeClient) SystemDiagnostics(ctx context.Context) (result diagnostics.Diagnostics, err error)

func (*NodeClient) SystemGetNodeFeatures 

func (n *NodeClient) SystemGetNodeFeatures(ctx context.Context) (feat []pkg.NodeFeature, err error)

func (*NodeClient) SystemHypervisor 

func (n *NodeClient) SystemHypervisor(ctx context.Context) (result string, err error)

func (*NodeClient) SystemVersion 

func (n *NodeClient) SystemVersion(ctx context.Context) (ver Version, err error)

type UsersCounters 

type UsersCounters struct {
	// Total deployments count
	Deployments int `json:"deployments"`
	// Total workloads count
	Workloads int `json:"workloads"`
}

UsersCounters the expected counters for deployments and workloads

type Version 

type Version struct {
	ZOS   string `json:"zos"`
	ZInit string `json:"zinit"`
}

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.