api

Documentation

Overview

Package api defines the committee scheduler API.

Index

• Constants
• Variables
• func RegisterService(server *grpc.Server, service Backend)
• func VotingPowerFromStake(t *quantity.Quantity) (int64, error)
• type Backend
  • func NewSchedulerClient(c *grpc.ClientConn) Backend
• type Committee
  • func (c *Committee) EncodedMembersHash() hash.Hash
  • func (c Committee) String() string
  • func (c Committee) Workers() []*CommitteeNode
• type CommitteeKind
  • func (k CommitteeKind) MarshalText() ([]byte, error)
  • func (k CommitteeKind) String() string
  • func (k *CommitteeKind) UnmarshalText(text []byte) error
• type CommitteeNode
• type ConsensusParameters
• type ElectedEvent
  • func (ev *ElectedEvent) EventKind() string
• type ForceElectCommitteeRole
• type Genesis
  • func (g *Genesis) SanityCheck(stakingTotalSupply *quantity.Quantity) error
• type GetCommitteesRequest
• type Role
  • func (r Role) MarshalText() ([]byte, error)
  • func (r Role) String() string
  • func (r *Role) UnmarshalText(text []byte) error
• type Validator

Constants

const (
	// RoleInvalid is an invalid role (should never appear on the wire).
	RoleInvalid Role = 0
	// RoleWorker indicates the node is a worker.
	RoleWorker Role = 1
	// RoleBackupWorker indicates the node is a backup worker.
	RoleBackupWorker Role = 2

	RoleInvalidName      = "invalid"
	RoleWorkerName       = "worker"
	RoleBackupWorkerName = "backup-worker"
)

const (
	// KindInvalid is an invalid committee.
	KindInvalid CommitteeKind = 0
	// KindComputeExecutor is an executor committee.
	KindComputeExecutor CommitteeKind = 1

	// MaxCommitteeKind is a dummy value used for iterating all committee kinds.
	MaxCommitteeKind = 2

	KindInvalidName         = "invalid"
	KindComputeExecutorName = "executor"
)

const ModuleName = "scheduler"

ModuleName is a unique module name for the scheduler module.

Variables

var BaseUnitsPerVotingPower quantity.Quantity

BaseUnitsPerVotingPower is the ratio of base units staked to validator power.

Functions

func RegisterService

func RegisterService(server *grpc.Server, service Backend)

RegisterService registers a new scheduler service with the given gRPC server.

func VotingPowerFromStake

func VotingPowerFromStake(t *quantity.Quantity) (int64, error)

VotingPowerFromStake computes that by dividing by BaseUnitsPerVotingPower.

NOTE: It's not that we're implementation-hiding the conversion though. It's just that otherwise if we accidentally skip the `IsInt64`, it would still appear to work, and that would be a bad thing to have in a routine that's written multiple times.

Types

type Backend

type Backend interface {
	// GetValidators returns the vector of consensus validators for
	// a given epoch.
	GetValidators(ctx context.Context, height int64) ([]*Validator, error)

	// GetCommittees returns the vector of committees for a given
	// runtime ID, at the specified block height, and optional callback
	// for querying the beacon for a given epoch/block height.
	//
	// Iff the callback is nil, `beacon.GetBlockBeacon` will be used.
	GetCommittees(ctx context.Context, request *GetCommitteesRequest) ([]*Committee, error)

	// WatchCommittees returns a channel that produces a stream of
	// Committee.
	//
	// Upon subscription, all committees for the current epoch will
	// be sent immediately.
	WatchCommittees(ctx context.Context) (<-chan *Committee, pubsub.ClosableSubscription, error)

	// StateToGenesis returns the genesis state at specified block height.
	StateToGenesis(ctx context.Context, height int64) (*Genesis, error)

	// ConsensusParameters returns the scheduler consensus parameters.
	ConsensusParameters(ctx context.Context, height int64) (*ConsensusParameters, error)

	// Cleanup cleans up the scheduler backend.
	Cleanup()
}

Backend is a scheduler implementation.

func NewSchedulerClient

func NewSchedulerClient(c *grpc.ClientConn) Backend

NewSchedulerClient creates a new gRPC scheduler client service.

type Committee

type Committee struct {
	// Kind is the functionality a committee exists to provide.
	Kind CommitteeKind `json:"kind"`

	// Members is the committee members.
	Members []*CommitteeNode `json:"members"`

	// RuntimeID is the runtime ID that this committee is for.
	RuntimeID common.Namespace `json:"runtime_id"`

	// ValidFor is the epoch for which the committee is valid.
	ValidFor beacon.EpochTime `json:"valid_for"`
}

Committee is a per-runtime (instance) committee.

func (*Committee) EncodedMembersHash

func (c *Committee) EncodedMembersHash() hash.Hash

EncodedMembersHash returns the encoded cryptographic hash of the committee members.

func (Committee) String

func (c Committee) String() string

String returns a string representation of a Committee.

func (Committee) Workers

func (c Committee) Workers() []*CommitteeNode

Workers returns committee nodes with Worker role.

type CommitteeKind

type CommitteeKind uint8

CommitteeKind is the functionality a committee exists to provide.

func (CommitteeKind) MarshalText

func (k CommitteeKind) MarshalText() ([]byte, error)

MarshalText encodes a CommitteeKind into text form.

func (CommitteeKind) String

func (k CommitteeKind) String() string

String returns a string representation of a CommitteeKind.

func (*CommitteeKind) UnmarshalText

func (k *CommitteeKind) UnmarshalText(text []byte) error

UnmarshalText decodes a text slice into a CommitteeKind.

type CommitteeNode

type CommitteeNode struct {
	// Role is the node's role in a committee.
	Role Role `json:"role"`

	// PublicKey is the node's public key.
	PublicKey signature.PublicKey `json:"public_key"`
}

CommitteeNode is a node participating in a committee.

type ConsensusParameters

type ConsensusParameters struct {
	// MinValidators is the minimum number of validators that MUST be
	// present in elected validator sets.
	MinValidators int `json:"min_validators"`

	// MaxValidators is the maximum number of validators that MAY be
	// present in elected validator sets.
	MaxValidators int `json:"max_validators"`

	// MaxValidatorsPerEntity is the maximum number of validators that
	// may be elected per entity in a single validator set.
	MaxValidatorsPerEntity int `json:"max_validators_per_entity"`

	// DebugBypassStake is true iff the scheduler should bypass all of
	// the staking related checks and operations.
	DebugBypassStake bool `json:"debug_bypass_stake,omitempty"`

	// RewardFactorEpochElectionAny is the factor for a reward
	// distributed per epoch to entities that have any node considered
	// in any election.
	RewardFactorEpochElectionAny quantity.Quantity `json:"reward_factor_epoch_election_any"`

	// DebugForceElect is the map of nodes that will always be elected
	// to a given role for a runtime.
	DebugForceElect map[common.Namespace]map[signature.PublicKey]*ForceElectCommitteeRole `json:"debug_force_elect,omitempty"`

	// DebugAllowWeakAlpha allows VRF based elections based on proofs
	// generated by an alpha value considered weak.
	DebugAllowWeakAlpha bool `json:"debug_allow_weak_alpha,omitempty"`
}

ConsensusParameters are the scheduler consensus parameters.

type ElectedEvent

type ElectedEvent struct {
	// Kinds are the elected committee kinds.
	Kinds []CommitteeKind `json:"kinds,omitempty"`
}

ElectedEvent is the elected committee kind event.

func (*ElectedEvent) EventKind

func (ev *ElectedEvent) EventKind() string

EventKind returns a string representation of this event's kind.

type ForceElectCommitteeRole

type ForceElectCommitteeRole struct {
	// Kind is the kind of committee to force-elect the node into.
	Kind CommitteeKind `json:"kind"`
	// Role is the role that the given node is force elected as.
	Role Role `json:"role"`
	// IsScheduler is true iff the node should be set as the scheduler.
	IsScheduler bool `json:"is_scheduler,omitempty"`
}

ForceElectCommitteeRole is the committee kind/role that a force-elected node is elected as.

type Genesis

type Genesis struct {
	// Parameters are the scheduler consensus parameters.
	Parameters ConsensusParameters `json:"params"`
}

Genesis is the committee scheduler genesis state.

func (*Genesis) SanityCheck

func (g *Genesis) SanityCheck(stakingTotalSupply *quantity.Quantity) error

SanityCheck does basic sanity checking on the genesis state.

type GetCommitteesRequest

type GetCommitteesRequest struct {
	Height    int64            `json:"height"`
	RuntimeID common.Namespace `json:"runtime_id"`
}

GetCommitteesRequest is a GetCommittees request.

type Role

type Role uint8

Role is the role a given node plays in a committee.

func (Role) MarshalText

func (r Role) MarshalText() ([]byte, error)

MarshalText encodes a Role into text form.

func (Role) String

func (r Role) String() string

String returns a string representation of a Role.

func (*Role) UnmarshalText

func (r *Role) UnmarshalText(text []byte) error

UnmarshalText decodes a text slice into a Role.

type Validator

type Validator struct {
	// ID is the validator Oasis node identifier.
	ID signature.PublicKey `json:"id"`

	// VotingPower is the validator's consensus voting power.
	VotingPower int64 `json:"voting_power"`
}

Validator is a consensus validator.