storage

package
v0.64.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 25, 2024 License: Apache-2.0 Imports: 7 Imported by: 269

Documentation

Overview

Package storage exposes the policy engine's storage layer.

Index

Constants

View Source 
const (
	// InternalErr indicates an unknown, internal error has occurred.
	InternalErr = "storage_internal_error"

	// NotFoundErr indicates the path used in the storage operation does not
	// locate a document.
	NotFoundErr = "storage_not_found_error"

	// WriteConflictErr indicates a write on the path enocuntered a conflicting
	// value inside the transaction.
	WriteConflictErr = "storage_write_conflict_error"

	// InvalidPatchErr indicates an invalid patch/write was issued. The patch
	// was rejected.
	InvalidPatchErr = "storage_invalid_patch_error"

	// InvalidTransactionErr indicates an invalid operation was performed
	// inside of the transaction.
	InvalidTransactionErr = "storage_invalid_txn_error"

	// TriggersNotSupportedErr indicates the caller attempted to register a
	// trigger against a store that does not support them.
	TriggersNotSupportedErr = "storage_triggers_not_supported_error"

	// WritesNotSupportedErr indicate the caller attempted to perform a write
	// against a store that does not support them.
	WritesNotSupportedErr = "storage_writes_not_supported_error"

	// PolicyNotSupportedErr indicate the caller attempted to perform a policy
	// management operation against a store that does not support them.
	PolicyNotSupportedErr = "storage_policy_not_supported_error"
)
View Source 
const (
	AddOp     PatchOp = iota
	RemoveOp          = iota
	ReplaceOp         = iota
)

Patch supports add, remove, and replace operations.

Variables

View Source 
var WriteParams = TransactionParams{
	Write: true,
}

WriteParams specifies the TransactionParams for a write transaction.

Functions

func IsIndexingNotSupported deprecated added in v0.5.0 

func IsIndexingNotSupported(error) bool

IsIndexingNotSupported is a stub for backwards-compatibility.

Deprecated: We no longer return IndexingNotSupported errors, so it is unnecessary to check for them.

func IsInvalidPatch added in v0.2.0 

func IsInvalidPatch(err error) bool

IsInvalidPatch returns true if this error is a InvalidPatchErr.

func IsInvalidTransaction added in v0.5.0 

func IsInvalidTransaction(err error) bool

IsInvalidTransaction returns true if this error is a InvalidTransactionErr.

func IsNotFound 

func IsNotFound(err error) bool

IsNotFound returns true if this error is a NotFoundErr.

func IsWriteConflictError added in v0.8.0 

func IsWriteConflictError(err error) bool

IsWriteConflictError returns true if this error a WriteConflictErr.

func MakeDir added in v0.8.0 

func MakeDir(ctx context.Context, store Store, txn Transaction, path Path) error

MakeDir inserts an empty object at path. If the parent path does not exist, MakeDir will create it recursively.

func NonEmpty added in v0.10.4 

func NonEmpty(ctx context.Context, store Store, txn Transaction) func([]string) (bool, error)

NonEmpty returns a function that tests if a path is non-empty. A path is non-empty if a Read on the path returns a value or a Read on any of the path prefixes returns a non-object value.

func ReadOne added in v0.5.3 

func ReadOne(ctx context.Context, store Store, path Path) (interface{}, error)

ReadOne is a convenience function to read a single value from the provided Store. It will create a new Transaction to perform the read with, and clean up after itself should an error occur.

func Txn added in v0.5.9 

func Txn(ctx context.Context, store Store, params TransactionParams, f func(Transaction) error) error

Txn is a convenience function that executes f inside a new transaction opened on the store. If the function returns an error, the transaction is aborted and the error is returned. Otherwise, the transaction is committed and the result of the commit is returned.

func WriteOne added in v0.5.3 

func WriteOne(ctx context.Context, store Store, op PatchOp, path Path, value interface{}) error

WriteOne is a convenience function to write a single value to the provided Store. It will create a new Transaction to perform the write with, and clean up after itself should an error occur.

Types

type Context added in v0.12.2 

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

Context is a simple container for key/value pairs.

func NewContext added in v0.12.2 

func NewContext() *Context

NewContext returns a new context object.

func (*Context) Get added in v0.12.2 

func (ctx *Context) Get(key interface{}) interface{}

Get returns the key value in the context.

func (*Context) Metrics added in v0.39.0 

func (ctx *Context) Metrics() metrics.Metrics

Metrics() allows using a Context's metrics. Returns nil if metrics were not attached to the Context.

func (*Context) Put added in v0.12.2 

func (ctx *Context) Put(key, value interface{})

Put adds a key/value pair to the context.

func (*Context) WithMetrics added in v0.39.0 

func (ctx *Context) WithMetrics(m metrics.Metrics) *Context

WithMetrics allows passing metrics via the Context. It puts the metrics object in the ctx, and returns the same ctx (not a copy) for convenience.

type DataEvent added in v0.5.3 

type DataEvent struct {
	Path    Path
	Data    interface{}
	Removed bool
}

DataEvent describes a change to a base data document.

type Error 

type Error struct {
	Code    string `json:"code"`
	Message string `json:"message"`
}

Error is the error type returned by the storage layer.

func (*Error) Error 

func (err *Error) Error() string

type Iterator added in v0.42.0 

type Iterator interface {
	Next() (*Update, error)
}

Iterator defines the interface that can be used to read files from a directory starting with files at the base of the directory, then sub-directories etc.

type MakeDirer added in v0.39.0 

type MakeDirer interface {
	MakeDir(context.Context, Transaction, Path) error
}

MakeDirer defines the interface a Store could realize to override the generic MakeDir functionality in storage.MakeDir

type PatchOp 

type PatchOp int

PatchOp is the enumeration of supposed modifications.

type Path added in v0.3.0 

type Path []string

Path refers to a document in storage.

func MustParsePath added in v0.3.0 

func MustParsePath(s string) Path

MustParsePath returns a new Path for s. If s cannot be parsed, this function will panic. This is mostly for test purposes.

func NewPathForRef added in v0.3.0 

func NewPathForRef(ref ast.Ref) (path Path, err error)

NewPathForRef returns a new path for the given ref.

func ParsePath added in v0.3.0 

func ParsePath(str string) (path Path, ok bool)

ParsePath returns a new path for the given str.

func ParsePathEscaped added in v0.8.1 

func ParsePathEscaped(str string) (path Path, ok bool)

ParsePathEscaped returns a new path for the given escaped str.

func (Path) Compare added in v0.3.0 

func (p Path) Compare(other Path) (cmp int)

Compare performs lexigraphical comparison on p and other and returns -1 if p is less than other, 0 if p is equal to other, or 1 if p is greater than other.

func (Path) Equal added in v0.3.0 

func (p Path) Equal(other Path) bool

Equal returns true if p is the same as other.

func (Path) HasPrefix added in v0.3.0 

func (p Path) HasPrefix(other Path) bool

HasPrefix returns true if p starts with other.

func (Path) Ref added in v0.3.0 

func (p Path) Ref(head *ast.Term) (ref ast.Ref)

Ref returns a ref that represents p rooted at head.

func (Path) String added in v0.3.0 

func (p Path) String() string

type Policy added in v0.5.0 

type Policy interface {
	ListPolicies(context.Context, Transaction) ([]string, error)
	GetPolicy(context.Context, Transaction, string) ([]byte, error)
	UpsertPolicy(context.Context, Transaction, string, []byte) error
	DeletePolicy(context.Context, Transaction, string) error
}

Policy defines the interface for policy module storage.

type PolicyEvent added in v0.5.3 

type PolicyEvent struct {
	ID      string
	Data    []byte
	Removed bool
}

PolicyEvent describes a change to a policy.

type PolicyNotSupported added in v0.5.0 

type PolicyNotSupported struct{}

PolicyNotSupported provides a default implementation of the policy interface which may be used if the backend does not support policy storage.

func (PolicyNotSupported) DeletePolicy added in v0.5.0 

func (PolicyNotSupported) DeletePolicy(context.Context, Transaction, string) error

DeletePolicy always returns a PolicyNotSupportedErr.

func (PolicyNotSupported) GetPolicy added in v0.5.0 

func (PolicyNotSupported) GetPolicy(context.Context, Transaction, string) ([]byte, error)

GetPolicy always returns a PolicyNotSupportedErr.

func (PolicyNotSupported) ListPolicies added in v0.5.0 

func (PolicyNotSupported) ListPolicies(context.Context, Transaction) ([]string, error)

ListPolicies always returns a PolicyNotSupportedErr.

func (PolicyNotSupported) UpsertPolicy added in v0.5.0 

func (PolicyNotSupported) UpsertPolicy(context.Context, Transaction, string, []byte) error

UpsertPolicy always returns a PolicyNotSupportedErr.

type Store added in v0.2.0 

type Store interface {
	Trigger
	Policy

	// NewTransaction is called create a new transaction in the store.
	NewTransaction(context.Context, ...TransactionParams) (Transaction, error)

	// Read is called to fetch a document referred to by path.
	Read(context.Context, Transaction, Path) (interface{}, error)

	// Write is called to modify a document referred to by path.
	Write(context.Context, Transaction, PatchOp, Path, interface{}) error

	// Commit is called to finish the transaction. If Commit returns an error, the
	// transaction must be automatically aborted by the Store implementation.
	Commit(context.Context, Transaction) error

	// Truncate is called to make a copy of the underlying store, write documents in the new store
	// by creating multiple transactions in the new store as needed and finally swapping
	// over to the new storage instance. This method must be called within a transaction on the original store.
	Truncate(context.Context, Transaction, TransactionParams, Iterator) error

	// Abort is called to cancel the transaction.
	Abort(context.Context, Transaction)
}

Store defines the interface for the storage layer's backend.

type Transaction added in v0.2.0 

type Transaction interface {
	ID() uint64
}

Transaction defines the interface that identifies a consistent snapshot over the policy engine's storage layer.

func NewTransactionOrDie added in v0.2.0 

func NewTransactionOrDie(ctx context.Context, store Store, params ...TransactionParams) Transaction

NewTransactionOrDie is a helper function to create a new transaction. If the storage layer cannot create a new transaction, this function will panic. This function should only be used for tests.

type TransactionParams added in v0.3.0 

type TransactionParams struct {

	// BasePaths indicates the top-level paths where write operations will be performed in this transaction.
	BasePaths []string

	// RootOverwrite is deprecated. Use BasePaths instead.
	RootOverwrite bool

	// Write indicates if this transaction will perform any write operations.
	Write bool

	// Context contains key/value pairs passed to triggers.
	Context *Context
}

TransactionParams describes a new transaction.

type Trigger added in v0.2.0 

type Trigger interface {
	Register(context.Context, Transaction, TriggerConfig) (TriggerHandle, error)
}

Trigger defines the interface that stores implement to register for change notifications when the store is changed.

type TriggerConfig added in v0.2.0 

type TriggerConfig struct {

	// OnCommit is invoked when a transaction is successfully committed. The
	// callback is invoked with a handle to the write transaction that
	// successfully committed before other clients see the changes.
	OnCommit func(context.Context, Transaction, TriggerEvent)
}

TriggerConfig contains the trigger registration configuration.

type TriggerEvent added in v0.5.0 

type TriggerEvent struct {
	Policy  []PolicyEvent
	Data    []DataEvent
	Context *Context
}

TriggerEvent describes the changes that caused the trigger to be invoked.

func (TriggerEvent) DataChanged added in v0.5.0 

func (e TriggerEvent) DataChanged() bool

DataChanged returns true if the trigger was caused by a data change.

func (TriggerEvent) IsZero added in v0.5.0 

func (e TriggerEvent) IsZero() bool

IsZero returns true if the TriggerEvent indicates no changes occurred. This function is primarily for test purposes.

func (TriggerEvent) PolicyChanged added in v0.5.0 

func (e TriggerEvent) PolicyChanged() bool

PolicyChanged returns true if the trigger was caused by a policy change.

type TriggerHandle added in v0.5.3 

type TriggerHandle interface {
	Unregister(context.Context, Transaction)
}

TriggerHandle defines the interface that can be used to unregister triggers that have been registered on a Store.

type TriggersNotSupported added in v0.2.0 

type TriggersNotSupported struct{}

TriggersNotSupported provides default implementations of the Trigger interface which may be used if the backend does not support triggers.

func (TriggersNotSupported) Register added in v0.2.0 

func (TriggersNotSupported) Register(context.Context, Transaction, TriggerConfig) (TriggerHandle, error)

Register always returns an error indicating triggers are not supported.

type Update added in v0.42.0 

type Update struct {
	Path     Path
	Value    []byte
	IsPolicy bool
}

Update contains information about a file

type WritesNotSupported added in v0.2.0 

type WritesNotSupported struct{}

WritesNotSupported provides a default implementation of the write interface which may be used if the backend does not support writes.

func (WritesNotSupported) Write added in v0.2.0 

func (WritesNotSupported) Write(context.Context, Transaction, PatchOp, Path, interface{}) error

Source Files

View all Source files

Directories

Path Synopsis
Package disk provides disk-based implementation of the storage.Store interface.
 Package disk provides disk-based implementation of the storage.Store interface.
Package inmem implements an in-memory version of the policy engine's storage layer.
 Package inmem implements an in-memory version of the policy engine's storage layer.
test
internal
errors
Package errors contains reusable error-related code for the storage layer.
 Package errors contains reusable error-related code for the storage layer.
ptr
Package ptr provides utilities for pointer operations using storage layer paths.
 Package ptr provides utilities for pointer operations using storage layer paths.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.