transform

Documentation

Overview

Package transform is a generated GoMock package.

Package transform is a generated GoMock package.

Index

• func NewLazyNode(node OpNode, controller *Controller) (OpNode, *Controller)
• func ProcessSimpleBlock(node simpleOpNode, controller *Controller, queryCtx *models.QueryContext, ...) error
• type BlockCache
  • func NewBlockCache() *BlockCache
  • func (c *BlockCache) Add(key parser.NodeID, b block.Block) error
  • func (c *BlockCache) Get(key parser.NodeID) (block.Block, bool)
  • func (c *BlockCache) Remove(key parser.NodeID)
• type BoundOp
• type BoundSpec
• type Controller
  • func (t *Controller) AddTransform(node OpNode)
  • func (t *Controller) BlockBuilder(queryCtx *models.QueryContext, blockMeta block.Metadata, ...) (block.Builder, error)
  • func (t *Controller) HasMultipleOperations() bool
  • func (t *Controller) Process(queryCtx *models.QueryContext, block block.Block) error
• type MetaNode
• type MockOpNode
  • func NewMockOpNode(ctrl *gomock.Controller) *MockOpNode
  • func (m *MockOpNode) EXPECT() *MockOpNodeMockRecorder
  • func (m *MockOpNode) Process(arg0 *models.QueryContext, arg1 parser.NodeID, arg2 block.Block) error
• type MockOpNodeMockRecorder
  • func (mr *MockOpNodeMockRecorder) Process(arg0, arg1, arg2 interface{}) *gomock.Call
• type MocksimpleOpNode
  • func NewMocksimpleOpNode(ctrl *gomock.Controller) *MocksimpleOpNode
  • func (m *MocksimpleOpNode) EXPECT() *MocksimpleOpNodeMockRecorder
  • func (m *MocksimpleOpNode) Params() parser.Params
  • func (m *MocksimpleOpNode) ProcessBlock(queryCtx *models.QueryContext, ID parser.NodeID, b block.Block) (block.Block, error)
• type MocksimpleOpNodeMockRecorder
  • func (mr *MocksimpleOpNodeMockRecorder) Params() *gomock.Call
  • func (mr *MocksimpleOpNodeMockRecorder) ProcessBlock(queryCtx, ID, b interface{}) *gomock.Call
• type OpNode
• type Options
• type Params
• type SeriesNode
• type StepNode
• type TimeSpec
  • func (ts TimeSpec) Bounds() models.Bounds

Functions

func NewLazyNode

func NewLazyNode(node OpNode, controller *Controller) (OpNode, *Controller)

NewLazyNode creates a new wrapper around a function fNode to make it support lazy initialization

func ProcessSimpleBlock

func ProcessSimpleBlock(node simpleOpNode, controller *Controller, queryCtx *models.QueryContext, ID parser.NodeID, b block.Block) error

ProcessSimpleBlock is a utility for OpNode instances which on receiving a block, process and propagate it immediately (as opposed to nodes which e.g. depend on multiple blocks). It adds instrumentation to the processing, and handles propagating the block downstream. OpNode's should call this as their implementation of the Process method:

func (n MyNode) Process(queryCtx *models.QueryContext, ID parser.NodeID, b block.Block) error {
    return transform.ProcessSimpleBlock(n, n.controller, queryCtx, ID, b)
}

Types

type BlockCache

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

BlockCache is used to cache blocks

func NewBlockCache

func NewBlockCache() *BlockCache

NewBlockCache creates a new BlockCache

func (*BlockCache) Add

func (c *BlockCache) Add(key parser.NodeID, b block.Block) error

Add the block to the cache, errors out if block already exists

func (*BlockCache) Get

func (c *BlockCache) Get(key parser.NodeID) (block.Block, bool)

Get the block from the cache TODO: Evaluate only a single process getting a block at a time

func (*BlockCache) Remove

func (c *BlockCache) Remove(key parser.NodeID)

Remove the block from the cache

type BoundOp

type BoundOp interface {
	Bounds() BoundSpec
}

BoundOp is implements by operations which have bounds

type BoundSpec

type BoundSpec struct {
	Range  time.Duration
	Offset time.Duration
}

BoundSpec is the bound spec for an operation

type Controller

type Controller struct {
	ID parser.NodeID
	// contains filtered or unexported fields
}

Controller controls the caching and forwarding the request to downstream.

func (*Controller) AddTransform

func (t *Controller) AddTransform(node OpNode)

AddTransform adds a dependent transformation to the controller.

func (*Controller) BlockBuilder

func (t *Controller) BlockBuilder(
	queryCtx *models.QueryContext,
	blockMeta block.Metadata,
	seriesMeta []block.SeriesMeta) (block.Builder, error)

BlockBuilder returns a BlockBuilder instance with associated metadata

func (*Controller) HasMultipleOperations

func (t *Controller) HasMultipleOperations() bool

HasMultipleOperations returns true if there are multiple operations.

func (*Controller) Process

func (t *Controller) Process(queryCtx *models.QueryContext, block block.Block) error

Process performs processing on the underlying transforms

type MetaNode

type MetaNode interface {
	// Meta provides the block metadata for the block using the input blocks' metadata as input
	Meta(meta block.Metadata) block.Metadata
	// SeriesMeta provides the series metadata for the block using the previous blocks' series metadata as input
	SeriesMeta(metas []block.SeriesMeta) []block.SeriesMeta
}

MetaNode is implemented by function nodes which can alter metadata for a block

type MockOpNode

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

MockOpNode is a mock of OpNode interface

func NewMockOpNode

func NewMockOpNode(ctrl *gomock.Controller) *MockOpNode

NewMockOpNode creates a new mock instance

func (*MockOpNode) EXPECT

func (m *MockOpNode) EXPECT() *MockOpNodeMockRecorder

EXPECT returns an object that allows the caller to indicate expected use

func (*MockOpNode) Process

func (m *MockOpNode) Process(arg0 *models.QueryContext, arg1 parser.NodeID, arg2 block.Block) error

Process mocks base method

type MockOpNodeMockRecorder

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

MockOpNodeMockRecorder is the mock recorder for MockOpNode

func (*MockOpNodeMockRecorder) Process

func (mr *MockOpNodeMockRecorder) Process(arg0, arg1, arg2 interface{}) *gomock.Call

Process indicates an expected call of Process

type MocksimpleOpNode

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

MocksimpleOpNode is a mock of simpleOpNode interface

func NewMocksimpleOpNode

func NewMocksimpleOpNode(ctrl *gomock.Controller) *MocksimpleOpNode

NewMocksimpleOpNode creates a new mock instance

func (*MocksimpleOpNode) EXPECT

func (m *MocksimpleOpNode) EXPECT() *MocksimpleOpNodeMockRecorder

EXPECT returns an object that allows the caller to indicate expected use

func (*MocksimpleOpNode) Params

func (m *MocksimpleOpNode) Params() parser.Params

Params mocks base method

func (*MocksimpleOpNode) ProcessBlock

func (m *MocksimpleOpNode) ProcessBlock(queryCtx *models.QueryContext, ID parser.NodeID, b block.Block) (block.Block, error)

ProcessBlock mocks base method

type MocksimpleOpNodeMockRecorder

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

MocksimpleOpNodeMockRecorder is the mock recorder for MocksimpleOpNode

func (*MocksimpleOpNodeMockRecorder) Params

func (mr *MocksimpleOpNodeMockRecorder) Params() *gomock.Call

Params indicates an expected call of Params

func (*MocksimpleOpNodeMockRecorder) ProcessBlock

func (mr *MocksimpleOpNodeMockRecorder) ProcessBlock(queryCtx, ID, b interface{}) *gomock.Call

ProcessBlock indicates an expected call of ProcessBlock

type OpNode

type OpNode interface {
	Process(queryCtx *models.QueryContext, ID parser.NodeID, block block.Block) error
}

OpNode represents the execution node

type Options

type Options struct {
	TimeSpec  TimeSpec
	Debug     bool
	BlockType models.FetchedBlockType
}

Options to create transform nodes

type Params

type Params interface {
	parser.Params
	Node(controller *Controller, opts Options) OpNode
}

Params are defined by transforms

type SeriesNode

type SeriesNode interface {
	MetaNode
	ProcessSeries(series block.Series) (block.Series, error)
}

SeriesNode is implemented by function nodes which can support series iteration

type StepNode

type StepNode interface {
	MetaNode
	ProcessStep(step block.Step) (block.Step, error)
}

StepNode is implemented by function nodes which can support step iteration

type TimeSpec

type TimeSpec struct {
	Start time.Time
	End   time.Time
	// Now captures the current time and fixes it throughout the request, we may let people override it in the future
	Now  time.Time
	Step time.Duration
}

TimeSpec defines the time bounds for the query execution. End is exclusive

func (TimeSpec) Bounds

func (ts TimeSpec) Bounds() models.Bounds

Bounds transforms a timespec to bounds