audit

Documentation

Index

• Variables
• type Config
• type Containment
• type Cursor
  • func NewCursor(metainfo *metainfo.Service) *Cursor
  • func (cursor *Cursor) NextStripe(ctx context.Context) (stripe *Stripe, more bool, err error)
• type PendingAudit
• type Report
• type Reporter
  • func NewReporter(overlay *overlay.Cache, containment Containment, maxRetries int) *Reporter
  • func (reporter *Reporter) RecordAudits(ctx context.Context, req *Report) (failed *Report, err error)
• type Service
  • func NewService(log *zap.Logger, config Config, metainfo *metainfo.Service, ...) (service *Service, err error)
  • func (service *Service) Close() error
  • func (service *Service) Run(ctx context.Context) (err error)
• type Share
• type Stripe
• type Verifier
  • func NewVerifier(log *zap.Logger, transport transport.Client, overlay *overlay.Cache, ...) *Verifier
  • func (verifier *Verifier) DownloadShares(ctx context.Context, limits []*pb.AddressedOrderLimit, stripeIndex int64, ...) (shares map[int]Share, nodes map[int]storj.NodeID, err error)
  • func (verifier *Verifier) Verify(ctx context.Context, stripe *Stripe) (verifiedNodes *Report, err error)

Variables

var (
	// ContainError is the containment errs class
	ContainError = errs.Class("containment error")

	// ErrContainedNotFound is the errs class for when a pending audit isn't found
	ErrContainedNotFound = errs.Class("pending audit not found")

	// ErrContainDelete is the errs class for when a pending audit can't be deleted
	ErrContainDelete = errs.Class("unable to delete pending audit")

	// ErrAlreadyExists is the errs class for when a pending audit with the same nodeID but different share data already exists
	ErrAlreadyExists = errs.Class("pending audit already exists for nodeID")
)

var Error = errs.Class("audit error")

Error is the default audit errs class

Types

type Config

type Config struct {
	MaxRetriesStatDB  int           `help:"max number of times to attempt updating a statdb batch" default:"3"`
	Interval          time.Duration `help:"how frequently segments are audited" default:"30s"`
	MinBytesPerSecond memory.Size   `help:"the minimum acceptable bytes that storage nodes can transfer per second to the satellite" default:"128B"`
}

Config contains configurable values for audit service

type Containment

type Containment interface {
	Get(ctx context.Context, nodeID pb.NodeID) (*PendingAudit, error)
	IncrementPending(ctx context.Context, pendingAudit *PendingAudit) error
	Delete(ctx context.Context, nodeID pb.NodeID) (bool, error)
}

Containment holds information about pending audits for contained nodes

type Cursor

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

Cursor keeps track of audit location in pointer db

func NewCursor

func NewCursor(metainfo *metainfo.Service) *Cursor

NewCursor creates a Cursor which iterates over pointer db

func (*Cursor) NextStripe

func (cursor *Cursor) NextStripe(ctx context.Context) (stripe *Stripe, more bool, err error)

NextStripe returns a random stripe to be audited. "more" is true except when we have completed iterating over metainfo. It can be disregarded if there is an error or stripe returned

type PendingAudit

type PendingAudit struct {
	NodeID            storj.NodeID
	PieceID           storj.PieceID
	StripeIndex       int64
	ShareSize         int32
	ExpectedShareHash []byte
	ReverifyCount     int32
}

PendingAudit contains info needed for retrying an audit for a contained node

type Report

type Report struct {
	Successes     storj.NodeIDList
	Fails         storj.NodeIDList
	Offlines      storj.NodeIDList
	PendingAudits []*PendingAudit
}

Report contains audit result lists for nodes that succeeded, failed, were offline, or have pending audits

type Reporter

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

Reporter records audit reports in overlay and implements the reporter interface

func NewReporter

func NewReporter(overlay *overlay.Cache, containment Containment, maxRetries int) *Reporter

NewReporter instantiates a reporter

func (*Reporter) RecordAudits

func (reporter *Reporter) RecordAudits(ctx context.Context, req *Report) (failed *Report, err error)

RecordAudits saves audit details to overlay

type Service

type Service struct {
	Cursor   *Cursor
	Verifier *Verifier
	Reporter reporter

	Loop sync2.Cycle
	// contains filtered or unexported fields
}

Service helps coordinate Cursor and Verifier to run the audit process continuously

func NewService

func NewService(log *zap.Logger, config Config, metainfo *metainfo.Service,
	orders *orders.Service, transport transport.Client, overlay *overlay.Cache,
	containment Containment, identity *identity.FullIdentity) (service *Service, err error)

NewService instantiates a Service with access to a Cursor and Verifier

func (*Service) Close

func (service *Service) Close() error

Close halts the audit loop

func (*Service) Run

func (service *Service) Run(ctx context.Context) (err error)

Run runs auditing service

type Share

type Share struct {
	Error    error
	PieceNum int
	Data     []byte
}

Share represents required information about an audited share

type Stripe

type Stripe struct {
	Index       int64
	Segment     *pb.Pointer
	SegmentPath storj.Path
}

Stripe keeps track of a stripe's index and its parent segment

type Verifier

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

Verifier helps verify the correctness of a given stripe

func NewVerifier

func NewVerifier(log *zap.Logger, transport transport.Client, overlay *overlay.Cache, orders *orders.Service, id *identity.FullIdentity, minBytesPerSecond memory.Size) *Verifier

NewVerifier creates a Verifier

func (*Verifier) DownloadShares

func (verifier *Verifier) DownloadShares(ctx context.Context, limits []*pb.AddressedOrderLimit, stripeIndex int64, shareSize int32) (shares map[int]Share, nodes map[int]storj.NodeID, err error)

DownloadShares downloads shares from the nodes where remote pieces are located

func (*Verifier) Verify

func (verifier *Verifier) Verify(ctx context.Context, stripe *Stripe) (verifiedNodes *Report, err error)

Verify downloads shares then verifies the data correctness at the given stripe