threefold.models_tfgrid #

these are the models for what we use on threefold

enum BidStatus {
	pending
	confirmed
	assigned
	cancelled
	done
}

enum BillingPeriod {
	hourly
	monthly
	yearly
	biannually
	triannually
}

enum ContractStatus {
	active
	cancelled
	error
	paused
}

struct Bid {
	db.Base
pub mut:
	customer_id    u32               // links back to customer for this capacity (user on ledger)
	requirements   map[string]string // e.g. compute_nodes:10, certified:true
	pricing        map[string]string // e.g. compute_nodes:10.2 (price per unit), certified_CU: 100.3 (price per CU)
	status         BidStatus
	obligation     bool // if obligation then will be charged and money needs to be in escrow
	start_date     u32  // epoch
	end_date       u32
	signature_user string // signature as done by a user/consumer to validate their identity and intent
	billing_period BillingPeriod
}

Bid - ROOT OBJECT

fn (self Bid) type_name() string

fn (self Bid) description(methodname string) string

fn (self Bid) example(methodname string) (string, string)

fn (self Bid) dump(mut e encoder.Encoder) !

struct BidArg {
pub mut:
	name           string
	description    string
	customer_id    u32
	requirements   map[string]string
	pricing        map[string]string
	status         BidStatus
	obligation     bool
	start_date     u32
	end_date       u32
	signature_user string
	billing_period BillingPeriod
}

struct CPUDevice {
pub mut:
	id          string // can be used in node
	cores       int    // Number of CPU cores
	passmark    int
	description string // Description of the CPU
	cpu_brand   string // Brand of the CPU
	cpu_version string // Version of the CPU
}

CPU device information

struct ComputeSlice {
pub mut:
	id                       int // the id of the slice in the node
	mem_gb                   f64
	storage_gb               f64
	passmark                 int
	vcores                   int
	cpu_oversubscription     int
	storage_oversubscription int
	price_range              []f64 // Min/max allowed price range for validation
	gpus                     u8    // nr of GPU's see node to know what GPU's are
	price_cc                 f64   // price per slice in cloud credits
	pricing_policy           PricingPolicy
	sla_policy               SLAPolicy
}

Compute slice (typically represents a base unit of compute)

struct ComputeSliceProvisioned {
pub mut:
	node_id              u32
	id                   u16 // the id of the slice in the node
	mem_gb               f64
	storage_gb           f64
	passmark             int
	vcores               int
	cpu_oversubscription int
	tags                 string
}

Provisioned compute slice

struct Contract {
	db.Base
pub mut:
	customer_id         u32 // links back to customer for this capacity
	compute_slices      []ComputeSliceProvisioned
	storage_slices      []StorageSliceProvisioned
	compute_slice_price f64 // price per 1 GB agreed upon
	storage_slice_price f64 // price per 1 GB agreed upon
	network_slice_price f64 // price per 1 GB agreed upon (transfer)
	status              ContractStatus
	start_date          u32 // epoch
	end_date            u32
	signature_user      string // signature as done by user/consumer
	signature_hoster    string // signature as done by the hoster
	billing_period      BillingPeriod
}

Contract - ROOT OBJECT

fn (self Contract) type_name() string

fn (self Contract) description(methodname string) string

fn (self Contract) example(methodname string) (string, string)

fn (self Contract) dump(mut e encoder.Encoder) !

struct ContractArg {
pub mut:
	name                string
	description         string
	customer_id         u32
	compute_slices      []ComputeSliceProvisioned
	storage_slices      []StorageSliceProvisioned
	compute_slice_price f64
	storage_slice_price f64
	network_slice_price f64
	status              ContractStatus
	start_date          u32
	end_date            u32
	signature_user      string
	signature_hoster    string
	billing_period      BillingPeriod
}

struct DBBid {
pub mut:
	db &db.DB @[skip; str: skip]
}

fn (mut self DBBid) new(args BidArg) !Bid

fn (mut self DBBid) set(o Bid) !Bid

fn (mut self DBBid) delete(id u32) !

fn (mut self DBBid) exist(id u32) !bool

fn (mut self DBBid) get(id u32) !Bid

fn (mut self DBBid) list() ![]Bid

struct DBContract {
pub mut:
	db &db.DB @[skip; str: skip]
}

fn (mut self DBContract) new(args ContractArg) !Contract

fn (mut self DBContract) set(o Contract) !Contract

fn (mut self DBContract) delete(id u32) !

fn (mut self DBContract) exist(id u32) !bool

fn (mut self DBContract) get(id u32) !Contract

fn (mut self DBContract) list() ![]Contract

struct DBNode {
pub mut:
	db &db.DB @[skip; str: skip]
}

fn (mut self DBNode) new(args NodeArg) !Node

fn (mut self DBNode) set(o Node) !Node

fn (mut self DBNode) delete(id u32) !

fn (mut self DBNode) exist(id u32) !bool

fn (mut self DBNode) get(id u32) !Node

fn (mut self DBNode) list() ![]Node

struct DBNodeGroup {
pub mut:
	db &db.DB @[skip; str: skip]
}

fn (mut self DBNodeGroup) new(args NodeGroupArg) !NodeGroup

fn (mut self DBNodeGroup) set(o NodeGroup) !NodeGroup

fn (mut self DBNodeGroup) delete(id u32) !

fn (mut self DBNodeGroup) exist(id u32) !bool

fn (mut self DBNodeGroup) get(id u32) !NodeGroup

fn (mut self DBNodeGroup) list() ![]NodeGroup

struct DBNodeGroupReputation {
pub mut:
	db &db.DB @[skip; str: skip]
}

fn (mut self DBNodeGroupReputation) new(args NodeGroupReputationArg) !NodeGroupReputation

fn (mut self DBNodeGroupReputation) set(o NodeGroupReputation) !NodeGroupReputation

fn (mut self DBNodeGroupReputation) delete(id u32) !

fn (mut self DBNodeGroupReputation) exist(id u32) !bool

fn (mut self DBNodeGroupReputation) get(id u32) !NodeGroupReputation

fn (mut self DBNodeGroupReputation) list() ![]NodeGroupReputation

struct DeviceInfo {
pub mut:
	vendor  string
	storage []StorageDevice
	memory  []MemoryDevice
	cpu     []CPUDevice
	gpu     []GPUDevice
	network []NetworkDevice
}

Aggregated device info for a node

struct GPUDevice {
pub mut:
	id          string // can be used in node
	cores       int    // Number of GPU cores
	memory_gb   f64    // Size of the GPU memory in gigabytes
	description string // Description of the GPU
	gpu_brand   string
	gpu_version string
}

GPU device information

struct MemoryDevice {
pub mut:
	id          string // can be used in node
	size_gb     f64    // Size of the memory device in gigabytes
	description string // Description of the memory device
}

Memory device information

struct NetworkDevice {
pub mut:
	id          string // can be used in node
	speed_mbps  int    // Network speed in Mbps
	description string // Description of the network device
}

Network device information

struct Node {
	db.Base
pub mut:
	nodegroupid      int // Link to node group
	uptime           int // Uptime percentage 0..100
	computeslices    []ComputeSlice
	storageslices    []StorageSlice
	devices          DeviceInfo
	country          string       // 2 letter code
	capacity         NodeCapacity // Hardware capacity details
	birthtime        u32          // first time node was active
	pubkey           string
	signature_node   string // signature done on node to validate pubkey with privkey
	signature_farmer string // signature as done by farmers to validate their identity
}

Grid4 Node model - ROOT OBJECT

fn (self Node) type_name() string

fn (self Node) description(methodname string) string

fn (self Node) example(methodname string) (string, string)

fn (self Node) dump(mut e encoder.Encoder) !

struct NodeArg {
pub mut:
	name             string
	description      string
	nodegroupid      int
	uptime           int
	computeslices    []ComputeSlice
	storageslices    []StorageSlice
	devices          DeviceInfo
	country          string
	capacity         NodeCapacity
	birthtime        u32
	pubkey           string
	signature_node   string
	signature_farmer string
}

struct NodeCapacity {
pub mut:
	storage_gb f64 // Total storage in gigabytes
	mem_gb     f64 // Total memory in gigabytes
	mem_gb_gpu f64 // Total GPU memory in gigabytes
	passmark   int // Passmark score for the node
	vcores     int // Total virtual cores
}

NodeCapacity represents the hardware capacity details of a node

struct NodeGroup {
	db.Base
pub mut:
	farmerid                            u32    // link back to farmer who owns the nodegroup
	secret                              string // only visible by farmer, in future encrypted, used to boot a node
	slapolicy                           SLAPolicy
	pricingpolicy                       PricingPolicy
	compute_slice_normalized_pricing_cc f64    // pricing in CC - cloud credit, per 2GB node slice
	storage_slice_normalized_pricing_cc f64    // pricing in CC - cloud credit, per 1GB storage slice
	signature_farmer                    string // signature as done by farmers to validate that they created this group
}

NodeGroup - ROOT OBJECT

fn (self NodeGroup) type_name() string

fn (self NodeGroup) description(methodname string) string

fn (self NodeGroup) example(methodname string) (string, string)

fn (self NodeGroup) dump(mut e encoder.Encoder) !

struct NodeGroupArg {
pub mut:
	name                                string
	description                         string
	farmerid                            u32
	secret                              string
	slapolicy                           SLAPolicy
	pricingpolicy                       PricingPolicy
	compute_slice_normalized_pricing_cc f64
	storage_slice_normalized_pricing_cc f64
	signature_farmer                    string
}

struct NodeGroupReputation {
	db.Base
pub mut:
	nodegroup_id u32
	reputation   int = 50 // between 0 and 100, earned over time
	uptime       int // between 0 and 100, set by system, farmer has no ability to set this
	nodes        []NodeReputation
}

NodeGroupReputation - ROOT OBJECT

fn (self NodeGroupReputation) type_name() string

fn (self NodeGroupReputation) description(methodname string) string

fn (self NodeGroupReputation) example(methodname string) (string, string)

fn (self NodeGroupReputation) dump(mut e encoder.Encoder) !

struct NodeGroupReputationArg {
pub mut:
	name         string
	description  string
	nodegroup_id u32
	reputation   int = 50
	uptime       int
	nodes        []NodeReputation
}

struct NodeReputation {
pub mut:
	node_id    u32
	reputation int = 50 // between 0 and 100, earned over time
	uptime     int // between 0 and 100, set by system
}

Individual node reputation information

struct PricingPolicy {
pub mut:
	name                       string // Human friendly policy name (e.g. "fixed", "market")
	details                    string // Optional free-form details as JSON-encoded string
	marketplace_year_discounts []int  // e.g. [30, 40, 50] means if user has more CC than 1Y utilization, 30% discount, etc.
}

Pricing policy for slices

struct SLAPolicy {
pub mut:
	uptime               f32 // Uptime in percentage (0..100)
	max_response_time_ms u32 // Max response time in ms
	sla_bandwidth_mbit   int // minimal mbits we can expect avg over 1h per node, 0 means we don't guarantee
	sla_penalty          int // 0-100, percent of money given back in relation to month if sla breached
}

SLA policy for slices

struct StorageDevice {
pub mut:
	id          string // can be used in node
	size_gb     f64    // Size of the storage device in gigabytes
	description string // Description of the storage device
}

Storage device information

struct StorageSlice {
pub mut:
	id             int // the id of the slice in the node
	price_cc       f64 // price per slice in cloud credits
	pricing_policy PricingPolicy
	sla_policy     SLAPolicy
}

Storage slice (typically 1GB of storage)

struct StorageSliceProvisioned {
pub mut:
	node_id         u32
	id              u16 // the id of the slice in the node
	storage_size_gb int
	tags            string
}

Provisioned storage slice