jobs

type Allocation struct {
	ID string

	Actor actor.Actor

	Job Job
	// contains filtered or unexported fields
}

type AllocationConfig struct {
	Executor    AllocationExecutor // the executor of the allocation
	Resources   types.Resources    // the HW resources required by the allocation
	Execution   types.SpecConfig   // the allocation execution configuration
	DNSName     string             // the internal DNS name of the allocation
	Keys        []string           // names of the authorized ssh keys for the allocation
	Provision   []string           // names of provisioning scripts to run (in order)
	HealthCheck string             // name of the script to run for health checks
}

type AllocationDeploymentConfig struct {
	Executor         AllocationExecutor
	Resources        types.Resources
	Execution        types.SpecConfig
	ProvisionScripts map[string][]byte
}

type AllocationDeploymentRequest struct {
	EnsembleID  string
	NodeID      string
	Allocations map[string]AllocationDeploymentConfig
}

type AllocationDeploymentResponse struct {
	OK          bool
	Error       string
	Allocations map[string]actor.Handle
	Tokens      ucan.TokenList // tokens granted for allocation capabilities
}

type AllocationDetails struct {
	Job      Job
	NodeID   string
	SourceID string
}

type AllocationExecutor string

type AllocationManifest struct {
	ID       string       // allocation unique id
	NodeID   string       // allocation node
	Handle   actor.Handle // handle of the allocation control actor
	DNSName  string       // (internal) DNS name of the allocation
	PrivAddr string       // (VPN) private IP address of the allocation peer
	Ports    map[int]int  // port mapping, public -> private
}

type AllocationStartRequest struct{}

type AllocationStartResponse struct {
	OK    bool
	Error string
}

type AllocationStatus string

type Bid struct {
	V1 *BidV1
}

type BidRequest struct {
	V1 *BidRequestV1
}

type BidRequestV1 struct {
	NodeID      string               // unique identifier for a node, within the context of an ensemble
	Executors   []AllocationExecutor // list of required executors to support the allocation(s)
	Resources   types.Resources      // (aggregate) required hardware resources
	Location    LocationConstraints  // node location constraints
	PublicPorts struct {
		Static  []int // statically configured public ports
		Dynamic int   // number of dynamic ports
	}
}

type BidV1 struct {
	EnsembleID string       // unique identifier for the ensemble
	NodeID     string       // unique identifier for a node; matches the id of the BidRequest to which this bid pertains
	Peer       string       // the peer ID of the node
	Location   Location     // the location of the node
	Handle     actor.Handle // the handle of the actor submitting the bid
	Signature  []byte
}

type CommitDeploymentRequest struct {
	EnsembleID string
	NodeID     string
}

type CommitDeploymentResponse struct {
	OK    bool
	Error string
}

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

type DeploymentStatus int

type EdgeConstraint struct {
	S, T string // (named) nodes connected by the edge
	RTT  uint   // maximum edge RTT in milliseconds
	BW   uint   // minimum edge bandwidth in Kbps
}

type EnsembleBidRequest struct {
	ID            string       // unique identifier of an ensemble (in the context of the orchestrator)
	Request       []BidRequest // list of node bid requests
	PeerExclusion []string     // list of peers to exclude from bidding
}

type EnsembleConfig struct {
	V1 *EnsembleConfigV1
}

type EnsembleConfigV1 struct {
	Allocations map[string]AllocationConfig // (named) allocations in the ensemble
	Nodes       map[string]NodeConfig       // (named) nodes in the ensemble
	Edges       []EdgeConstraint            // network edge constraints
	Supervisor  SupervisorConfig            // supervision structure
	Keys        map[string]string           // (named) ssh public keys relevant to the allocation
	Scripts     map[string][]byte           // (named) provisioning scripts
}

type EnsembleManifest struct {
	ID           string                        // ensemble globally unique id
	Orchestrator actor.Handle                  // orchestrator actor
	Allocations  map[string]AllocationManifest // allocation name -> manifest
	Nodes        map[string]NodeManifest       // node name -> manifest
}

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

type Job struct {
	ID               string
	Resources        types.Resources
	Execution        types.SpecConfig
	ProvisionScripts map[string][]byte
}

type Location struct {
	Region  string // geographic region of the location (required)
	Country string // country (code or name) of the location (optional)
	City    string // city of the location; optional but country must be specified if not empty
	ASN     uint   // Autonomous System Number for the location (optional)
	ISP     string // Internet Service Provider name for the location (optional)
}

type LocationConstraints struct {
	Accept []Location // acceptable location constraints (disjunction)
	Reject []Location // negative location constraints (conjunction); eg !USA for GPDR purposes
}

type NodeConfig struct {
	Allocations []string            // the list of (named) allocations in the node
	Ports       []PortConfig        // the port mapping configuration for the node
	Location    LocationConstraints // the geographical location constraints for the node
	Peer        string              // (optional) a fixed peer for the node

}

type NodeManifest struct {
	ID          string       // node unique id
	Peer        string       // peer where the node is running
	Handle      actor.Handle // handle of the control actor for the node
	PubAddrss   []string     // public IP4/6 address of the node peer
	Location    Location     // location of the peer
	Allocations []string     // allocations in the nod
}

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

type PortConfig struct {
	Public     int    // the public port 0 for any
	Private    int    // the private mapping
	Allocation string // the allocation where the port is mapped
}

type RestartAllocationRequest struct {
	AllocationID string
}

type RestartAllocationResponse struct {
	OK    bool
	Error string
}

type RevertDeploymentMessage struct {
	EnsembleID     string
	AllocationsIDs []string
}

type Status struct {
	JobResources types.Resources
	Status       AllocationStatus
}

type SubnetAcceptPeerRequest struct {
	SubnetID string
	PeerID   string
	IP       string
}

type SubnetAcceptPeerResponse struct {
	OK    bool
	Error string
}

type SubnetAddPeerRequest struct {
	SubnetID string
	PeerID   string
	IP       string
}

type SubnetAddPeerResponse struct {
	OK    bool
	Error string
}

type SubnetCreateRequest struct {
	SubnetID     string
	IP           string
	RoutingTable map[string]string
}

type SubnetCreateResponse struct {
	OK    bool
	Error string
}

type SubnetDNSAddRecordRequest struct {
	SubnetID   string
	DomainName string
	IP         string
}

type SubnetDNSAddRecordResponse struct {
	OK    bool
	Error string
}

type SubnetDNSRemoveRecordRequest struct {
	SubnetID   string
	DomainName string
}

type SubnetDNSRemoveRecordResponse struct {
	OK    bool
	Error string
}

type SubnetDestroyRequest struct {
	SubnetID string
}

type SubnetDestroyResponse struct {
	OK    bool
	Error string
}

type SubnetMapPortRequest struct {
	SubnetID   string
	Protocol   string
	SourceIP   string
	SourcePort string
	DestIP     string
	DestPort   string
}

type SubnetMapPortResponse struct {
	OK    bool
	Error string
}

type SubnetRemovePeerRequest struct {
	SubnetID string
	PeerID   string
}

type SubnetRemovePeerResponse struct {
	OK    bool
	Error string
}

type SubnetUnmapPortRequest struct {
	SubnetID   string
	Protocol   string
	SourceIP   string
	SourcePort string
	DestIP     string
	DestPort   string
}

type SubnetUnmapPortResponse struct {
	OK    bool
	Error string
}

type SupervisorConfig struct {
	Strategy    SupervisorStrategy // the strategy for the supervision group
	Allocations []string           // allocations in this supervision group
	Children    []SupervisorConfig // allocation children for recursive groups
}

type SupervisorStrategy string

type VerifyEdgeConstraintRequest struct {
	EnsembleID string // the ensemble identifier
	S, T       string // the peer IDs of the edge S->T
	RTT        uint   //  maximum RTT in ms (if > 0)
	BW         uint   // minim BW in Kbps
}

type VerifyEdgeConstraintResponse struct {
	OK    bool
	Error string
}