storj/pkg/audit/reporter.go

// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.

package audit

import (
	"context"

	"github.com/zeebo/errs"

	"storj.io/storj/pkg/overlay"
	"storj.io/storj/pkg/storj"
)

type reporter interface {
	RecordAudits(ctx context.Context, req *RecordAuditsInfo) (failed *RecordAuditsInfo, err error)
}

// Reporter records audit reports in overlay and implements the reporter interface
type Reporter struct {
	overlay     *overlay.Cache
	containment Containment
	maxRetries  int
}

// RecordAuditsInfo is a struct containing arguments/return values for RecordAudits()
type RecordAuditsInfo struct {
	SuccessNodeIDs storj.NodeIDList
	FailNodeIDs    storj.NodeIDList
	OfflineNodeIDs storj.NodeIDList
	PendingAudits  []*PendingAudit
}

// NewReporter instantiates a reporter
func NewReporter(overlay *overlay.Cache, containment Containment, maxRetries int) *Reporter {
	return &Reporter{overlay: overlay, containment: containment, maxRetries: maxRetries}
}

// RecordAudits saves failed audit details to overlay
func (reporter *Reporter) RecordAudits(ctx context.Context, req *RecordAuditsInfo) (failed *RecordAuditsInfo, err error) {
	successNodeIDs := req.SuccessNodeIDs
	failNodeIDs := req.FailNodeIDs
	offlineNodeIDs := req.OfflineNodeIDs
	pendingAudits := req.PendingAudits

	var errlist errs.Group

	retries := 0
	for retries < reporter.maxRetries {
		if len(successNodeIDs) == 0 && len(failNodeIDs) == 0 && len(offlineNodeIDs) == 0 {
			return nil, nil
		}

		errlist = errs.Group{}

		if len(successNodeIDs) > 0 {
			successNodeIDs, err = reporter.recordAuditSuccessStatus(ctx, successNodeIDs)
			if err != nil {
				errlist.Add(err)
			}
		}
		if len(failNodeIDs) > 0 {
			failNodeIDs, err = reporter.recordAuditFailStatus(ctx, failNodeIDs)
			if err != nil {
				errlist.Add(err)
			}
		}
		if len(offlineNodeIDs) > 0 {
			offlineNodeIDs, err = reporter.recordOfflineStatus(ctx, offlineNodeIDs)
			if err != nil {
				errlist.Add(err)
			}
		}
		if len(pendingAudits) > 0 {
			pendingAudits, err = reporter.recordPendingAudits(ctx, pendingAudits)
			if err != nil {
				errlist.Add(err)
			}
		}

		retries++
	}

	err = errlist.Err()
	if retries >= reporter.maxRetries && err != nil {
		return &RecordAuditsInfo{
			SuccessNodeIDs: successNodeIDs,
			FailNodeIDs:    failNodeIDs,
			OfflineNodeIDs: offlineNodeIDs,
			PendingAudits:  pendingAudits,
		}, errs.Combine(Error.New("some nodes failed to be updated in overlay"), err)
	}
	return nil, nil
}

// recordAuditFailStatus updates nodeIDs in overlay with isup=true, auditsuccess=false
func (reporter *Reporter) recordAuditFailStatus(ctx context.Context, failedAuditNodeIDs storj.NodeIDList) (failed storj.NodeIDList, err error) {
	var errlist errs.Group
	for _, nodeID := range failedAuditNodeIDs {
		_, err := reporter.overlay.UpdateStats(ctx, &overlay.UpdateRequest{
			NodeID:       nodeID,
			IsUp:         true,
			AuditSuccess: false,
		})
		if err != nil {
			failed = append(failed, nodeID)
			errlist.Add(err)
		}
	}
	if len(failed) > 0 {
		return failed, errs.Combine(Error.New("failed to record some audit fail statuses in overlay"), errlist.Err())
	}
	return nil, nil
}

// recordOfflineStatus updates nodeIDs in overlay with isup=false
func (reporter *Reporter) recordOfflineStatus(ctx context.Context, offlineNodeIDs storj.NodeIDList) (failed storj.NodeIDList, err error) {
	var errlist errs.Group
	for _, nodeID := range offlineNodeIDs {
		_, err := reporter.overlay.UpdateUptime(ctx, nodeID, false)
		if err != nil {
			failed = append(failed, nodeID)
			errlist.Add(err)
		}
	}
	if len(failed) > 0 {
		return failed, errs.Combine(Error.New("failed to record some audit offline statuses in overlay"), errlist.Err())
	}
	return nil, nil
}

// recordAuditSuccessStatus updates nodeIDs in overlay with isup=true, auditsuccess=true
func (reporter *Reporter) recordAuditSuccessStatus(ctx context.Context, successNodeIDs storj.NodeIDList) (failed storj.NodeIDList, err error) {
	var errlist errs.Group
	for _, nodeID := range successNodeIDs {
		_, err := reporter.overlay.UpdateStats(ctx, &overlay.UpdateRequest{
			NodeID:       nodeID,
			IsUp:         true,
			AuditSuccess: true,
		})
		if err != nil {
			failed = append(failed, nodeID)
			errlist.Add(err)
		}
	}
	if len(failed) > 0 {
		return failed, errs.Combine(Error.New("failed to record some audit success statuses in overlay"), errlist.Err())
	}
	return nil, nil
}

// recordPendingAudits updates the containment status of nodes with pending audits
func (reporter *Reporter) recordPendingAudits(ctx context.Context, pendingAudits []*PendingAudit) (failed []*PendingAudit, err error) {
	var errlist errs.Group
	for _, pendingAudit := range pendingAudits {
		err := reporter.containment.IncrementPending(ctx, pendingAudit)
		if err != nil {
			failed = append(failed, pendingAudit)
			errlist.Add(err)
		}
	}
	if len(failed) > 0 {
		return failed, errs.Combine(Error.New("failed to record some pending audits"), errlist.Err())
	}
	return nil, nil
}