Grid4 Data Model

This module defines data models for nodes, groups, and slices in a cloud/grid infrastructure. Each root object is marked with @[heap] and can be indexed for efficient querying.

Root Objects Overview

Node

Represents a single node in the grid with slices, devices, and capacity.

NodeGroup

Represents a group of nodes owned by a farmer, with policies.

ComputeSlice

Represents a compute slice (e.g., 1GB memory unit).

StorageSlice

Represents a 1GB storage slice.

DeviceInfo

Hardware device information for a node.

StorageDevice

MemoryDevice

CPUDevice

GPUDevice

NetworkDevice

NodeCapacity

Aggregated hardware capacity for a node.

SLAPolicy

Service Level Agreement policy for slices or node groups.

PricingPolicy

Pricing policy for slices or node groups.

fn play(mut plbook PlayBook) !map[string]&Node

this play script should never be called from hero directly its called by gridsimulator

enum BidStatus {
	pending
	confirmed
	assigned
	cancelled
	done
}

enum ReservationStatus {
	pending
	confirmed
	assigned
	cancelled
	done
}

struct Bid {
pub mut:
	id                u32
	customer_id       u32 // links back to customer for this capacity (user on ledger)
	compute_slices_nr int // nr of slices I need in 1 machine
	compute_slice     f64 // price per 1 GB slice I want to accept
	storage_slices    []u32
	status            BidStatus
	obligation        bool // if obligation then will be charged and money needs to be in escrow, otherwise its an intent
	start_date        u32  // epoch
	end_date          u32
}

I can bid for infra, and optionally get accepted

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
}

struct ComputeSlice {
pub mut:
	nodeid                   u32 // the node in the grid, there is an object describing the node
	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 = [0.0, 0.0]
	gpus                     u8  // nr of GPU's see node to know what GPU's are
	price_cc                 f64 // price per slice (even if the grouped one)
	pricing_policy           PricingPolicy
	sla_policy               SLAPolicy
}

typically 1GB of memory, but can be adjusted based based on size of machine

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

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
}

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
}

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
}

struct Node {
pub mut:
	id               int
	nodegroupid      int
	uptime           int // 0..100
	computeslices    []ComputeSlice
	storageslices    []StorageSlice
	devices          DeviceInfo
	country          string       // 2 letter code as specified in lib/data/countries/data/countryInfo.txt, use that library for validation
	capacity         NodeCapacity // Hardware capacity details
	provisiontime    u32          // lets keep it simple and compatible
	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
}

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 {
pub mut:
	id                                  u32
	farmerid                            u32    // link back to farmer who owns the nodegroup, is a user?
	secret                              string // only visible by farmer, in future encrypted, used to boot a node
	description                         string
	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
	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
}

is a root object, is the only obj farmer needs to configure in the UI, this defines how slices will be created

struct PricingPolicy {
pub mut:
	marketplace_year_discounts []int = [30, 40, 50] // e.g. 30,40,50 means if user has more CC in wallet than 1 year utilization on all his purchaes then this provider gives 30%, 2Y 40%, ...
	volume_discounts           []int = [10, 20, 30] // e.g. 10,20,30
}

struct Reservation {
pub mut:
	id             u32
	customer_id    u32 // links back to customer for this capacity
	compute_slices []u32
	storage_slices []u32
	status         ReservationStatus
	start_date     u32 // epoch
	end_date       u32
}

struct SLAPolicy {
pub mut:
	sla_uptime         int // should +90
	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, e.g. 200 means we return 2 months worth of rev if sla missed
}

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
}

struct StorageSlice {
pub mut:
	nodeid         u32 // the node in the grid
	id             int // the id of the slice in the node, are tracked in the node itself
	price_cc       f64 // price per slice (even if the grouped one)
	pricing_policy PricingPolicy
	sla_policy     SLAPolicy
}

1GB of storage