master

type Config ¶

type Config struct {
	Addr               string // Address for answering requests / receiving heartbeats.
	UseFailure         bool   // Whether to enable the failure service.
	RejectReqThreshold int    // Pending incoming requests on 'SrvAddr' are rejected after this threshold.

	ConsistencyCheckInterval time.Duration // How often to do a consistency check

	RaftACSpec string // Spec for raft autoconfig.
}

Config encapsulates parameters for the server.

type CuratorInfo ¶

type CuratorInfo struct {
	// What curator ID is this?
	ID core.CuratorID

	// Address for RPCs and http status.
	// These addrs are for the latest (and possibly stale) primary.
	Addr string

	// System clock time of when we received the last heartbeat from the host representing
	// this curator ID.
	//
	// We can't really take action when a curator dies.  Another member of the curator's
	// replication group has to take over, or we perhaps page an SRE.
	LastHeartbeat time.Time

	// How many additional partitions the curator can ask for. When this
	// quota drops to 0, 'newPartition' will fail. The quota will be
	// refreshed regularly.
	NewPartitionQuota uint32
}

CuratorInfo describes a curator. This is not persisted in the durable state, but rather being kept in memory.

Since we don't persist the address and last heartbeat time, when a master failover happens, the new leader cannot service requests until it hears heartbeat from the curators. See PL-1102.

Since we don't persist the new partition quota in durable state, when a master failover happens, the new leader will reset the quota for each curator and thus it's possible that a curator can have be allocated more partitions in such a case. However, we made this decision because this this quota is kind of "soft" limit in the sense that we just want to prevent a buggy client/curator from grabbing too many partitions, but not necessarily enforce that each curator cannot get more than the limit. Assuming master failure is rare, the chance of exceeding the quota should not appear too frequently.

type Master ¶

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

The Master assigns partitions of the BlobID space to curators, and forwards clients to the correct curator for their requests.

func NewMaster(cfg Config, stateCfg durable.StateConfig, r *raft.Raft) *Master

type MasterCtlHandler ¶

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

MasterCtlHandler defines control-oriented methods that conform to the Go's RPC requirement.

func (h *MasterCtlHandler) CuratorHeartbeat(req core.CuratorHeartbeatReq, reply *core.CuratorHeartbeatReply) error

func (h *MasterCtlHandler) MasterTractserverHeartbeat(req core.MasterTractserverHeartbeatReq, reply *core.MasterTractserverHeartbeatReply) error

func (h *MasterCtlHandler) NewPartition(req core.NewPartitionReq, reply *core.NewPartitionReply) error

func (h *MasterCtlHandler) RegisterCurator(req core.RegisterCuratorReq, reply *core.RegisterCuratorReply) error

func (h *MasterCtlHandler) RegisterTractserver(req core.RegisterTractserverReq, reply *core.RegisterTractserverReply) error

type MasterSrvHandler ¶

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

MasterSrvHandler defines client-oriented methods that conform to the Go's RPC requirement. Different from MasterCtlHandler, MasterSrvHandler is rate-limited.

func (h *MasterSrvHandler) GetTractserverInfo(req core.GetTractserverInfoReq, reply *core.GetTractserverInfoReply) error

func (h *MasterSrvHandler) ListPartitions(req core.ListPartitionsReq, reply *core.ListPartitionsReply) error

func (h *MasterSrvHandler) LookupCurator(req core.LookupCuratorReq, reply *core.LookupCuratorReply) error

func (h *MasterSrvHandler) LookupPartition(req core.LookupPartitionReq, reply *core.LookupPartitionReply) error

func (h *MasterSrvHandler) MasterCreateBlob(req core.MasterCreateBlobReq, reply *core.LookupCuratorReply) error

type Server ¶

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

Server is the RPC server implementation for the Master.

func NewServer(master *Master, cfg Config, raft *raft.Raft, storage *raft.Storage) *Server

func (s *Server) Start() (err error)

type StatusData ¶

type StatusData struct {
	JobName      string
	Cfg          Config
	LeaderAddr   string
	Members      []string
	RaftTerm     uint64
	FreeMem      uint64
	TotalMem     uint64
	Curators     []CuratorInfo
	Tractservers []TractserverInfo

	Reboot time.Time
	CtlRPC map[string]string
	SrvRPC map[string]string
	Now    time.Time
}

StatusData includes master status info.

type TractserverInfo ¶

type TractserverInfo struct {
	core.TractserverInfo
}

TractserverInfo contains information about the last heartbeat received from a TS.