archiver

Documentation

Index

• func MaxArchivalIterationTimeout() time.Duration
• func NewReplayMetricsClient(client metrics.Client, ctx workflow.Context) metrics.Client
• func NewReplayMetricsScope(scope metrics.Scope, ctx workflow.Context) metrics.Scope
• type ArchivalTarget
• type ArchiveRequest
• type BootstrapContainer
• type Client
  • func NewClient(metricsClient metrics.Client, logger log.Logger, ...) Client
• type ClientMock
  • func (_m *ClientMock) Archive(_a0 context.Context, _a1 *ClientRequest) (*ClientResponse, error)
• type ClientRequest
• type ClientResponse
• type ClientWorker
  • func NewClientWorker(container *BootstrapContainer) ClientWorker
• type Config
• type Handler
  • func NewHandler(ctx workflow.Context, logger log.Logger, metricsClient metrics.Client, ...) Handler
• type MockHandler
  • func (_m *MockHandler) Finished() []uint64
  • func (_m *MockHandler) Start()
• type Pump
  • func NewPump(ctx workflow.Context, logger log.Logger, metricsClient metrics.Client, ...) Pump
• type PumpMock
  • func (_m *PumpMock) Run() PumpResult
• type PumpResult

Functions

func MaxArchivalIterationTimeout

func MaxArchivalIterationTimeout() time.Duration

MaxArchivalIterationTimeout returns the max allowed timeout for a single iteration of archival workflow

func NewReplayMetricsClient

func NewReplayMetricsClient(client metrics.Client, ctx workflow.Context) metrics.Client

NewReplayMetricsClient creates a metrics client which is aware of cadence's replay mode

func NewReplayMetricsScope

func NewReplayMetricsScope(scope metrics.Scope, ctx workflow.Context) metrics.Scope

NewReplayMetricsScope creates a metrics scope which is aware of cadence's replay mode

Types

type ArchivalTarget

type ArchivalTarget int

ArchivalTarget is either history or visibility

const (
	// ArchiveTargetHistory is the archive target for workflow history
	ArchiveTargetHistory ArchivalTarget = iota
	// ArchiveTargetVisibility is the archive target for workflow visibility record
	ArchiveTargetVisibility
)

type ArchiveRequest

type ArchiveRequest struct {
	DomainID   string
	DomainName string
	WorkflowID string
	RunID      string

	// history archival
	ShardID              int
	BranchToken          []byte
	NextEventID          int64
	CloseFailoverVersion int64
	URI                  string // should be historyURI, but keep the existing name for backward compatibility

	// visibility archival
	WorkflowTypeName   string
	StartTimestamp     int64
	ExecutionTimestamp int64
	CloseTimestamp     int64
	CloseStatus        types.WorkflowExecutionCloseStatus
	HistoryLength      int64
	Memo               *types.Memo
	SearchAttributes   map[string][]byte
	VisibilityURI      string

	// archival targets: history and/or visibility
	Targets []ArchivalTarget
}

ArchiveRequest is the request signal sent to the archival workflow

type BootstrapContainer

type BootstrapContainer struct {
	PublicClient     workflowserviceclient.Interface
	MetricsClient    metrics.Client
	Logger           log.Logger
	HistoryV2Manager persistence.HistoryManager
	DomainCache      cache.DomainCache
	Config           *Config
	ArchiverProvider provider.ArchiverProvider
}

BootstrapContainer contains everything need for bootstrapping

type Client

type Client interface {
	Archive(context.Context, *ClientRequest) (*ClientResponse, error)
}

Client is used to archive workflow histories

func NewClient

func NewClient(
	metricsClient metrics.Client,
	logger log.Logger,
	publicClient workflowserviceclient.Interface,
	numWorkflows dynamicconfig.IntPropertyFn,
	requestRPS dynamicconfig.IntPropertyFn,
	archiverProvider provider.ArchiverProvider,
) Client

NewClient creates a new Client

type ClientMock

type ClientMock struct {
	mock.Mock
}

ClientMock is an autogenerated mock type for the Client type

func (*ClientMock) Archive

func (_m *ClientMock) Archive(_a0 context.Context, _a1 *ClientRequest) (*ClientResponse, error)

Archive provides a mock function with given fields: _a0, _a1

type ClientRequest

type ClientRequest struct {
	ArchiveRequest       *ArchiveRequest
	CallerService        string
	AttemptArchiveInline bool
}

ClientRequest is the archive request sent to the archiver client

type ClientResponse

type ClientResponse struct {
	HistoryArchivedInline bool
}

ClientResponse is the archive response returned from the archiver client

type ClientWorker

type ClientWorker interface {
	Start() error
	Stop()
}

ClientWorker is a cadence client worker

func NewClientWorker

func NewClientWorker(container *BootstrapContainer) ClientWorker

NewClientWorker returns a new ClientWorker

type Config

type Config struct {
	ArchiverConcurrency           dynamicconfig.IntPropertyFn
	ArchivalsPerIteration         dynamicconfig.IntPropertyFn
	TimeLimitPerArchivalIteration dynamicconfig.DurationPropertyFn
}

Config for ClientWorker

type Handler

type Handler interface {
	Start()
	Finished() []uint64
}

Handler is used to process archival requests

func NewHandler

func NewHandler(
	ctx workflow.Context,
	logger log.Logger,
	metricsClient metrics.Client,
	concurrency int,
	requestCh workflow.Channel,
) Handler

NewHandler returns a new Handler

type MockHandler

type MockHandler struct {
	mock.Mock
}

MockHandler is an autogenerated mock type for the Archiver type

func (*MockHandler) Finished

func (_m *MockHandler) Finished() []uint64

Finished provides a mock function with given fields:

func (*MockHandler) Start

func (_m *MockHandler) Start()

Start provides a mock function with given fields:

type Pump

type Pump interface {
	Run() PumpResult
}

Pump pumps archival requests into request channel

func NewPump

func NewPump(
	ctx workflow.Context,
	logger log.Logger,
	metricsClient metrics.Client,
	carryover []ArchiveRequest,
	timeout time.Duration,
	requestLimit int,
	requestCh workflow.Channel,
	signalCh workflow.Channel,
) Pump

NewPump returns a new Pump

type PumpMock

type PumpMock struct {
	mock.Mock
}

PumpMock is an autogenerated mock type for the Pump type

func (*PumpMock) Run

func (_m *PumpMock) Run() PumpResult

Run provides a mock function with given fields:

type PumpResult

type PumpResult struct {
	PumpedHashes          []uint64
	UnhandledCarryover    []ArchiveRequest
	TimeoutWithoutSignals bool
}

PumpResult is the result of pumping requests into request channel