pachyderm: github.com/pachyderm/pachyderm/src/server/pkg/transactionenv Index | Files

package transactionenv

import "github.com/pachyderm/pachyderm/src/server/pkg/transactionenv"

Index

Package Files

env.go

type AuthTransactionServer Uses

type AuthTransactionServer interface {
    AuthorizeInTransaction(*TransactionContext, *auth.AuthorizeRequest) (*auth.AuthorizeResponse, error)

    GetScopeInTransaction(*TransactionContext, *auth.GetScopeRequest) (*auth.GetScopeResponse, error)
    SetScopeInTransaction(*TransactionContext, *auth.SetScopeRequest) (*auth.SetScopeResponse, error)

    GetACLInTransaction(*TransactionContext, *auth.GetACLRequest) (*auth.GetACLResponse, error)
    SetACLInTransaction(*TransactionContext, *auth.SetACLRequest) (*auth.SetACLResponse, error)
}

AuthTransactionServer is an interface for the transactionally-supported methods that can be called through the auth server.

type AuthWrites Uses

type AuthWrites interface {
    SetScope(*auth.SetScopeRequest) (*auth.SetScopeResponse, error)
    SetACL(*auth.SetACLRequest) (*auth.SetACLResponse, error)
}

AuthWrites is an interface providing a wrapper for each operation that may be appended to a transaction through the Auth server. Each call may either directly run the request through Auth or append it to the active transaction, depending on if there is an active transaction in the client context.

type PfsPropagater Uses

type PfsPropagater interface {
    PropagateCommit(branch *pfs.Branch, isNewCommit bool) error
    Run() error
}

PfsPropagater is the interface that PFS implements to propagate commits at the end of a transaction. It is defined here to avoid a circular dependency.

type PfsTransactionServer Uses

type PfsTransactionServer interface {
    NewPropagater(col.STM) PfsPropagater

    CreateRepoInTransaction(*TransactionContext, *pfs.CreateRepoRequest) error
    InspectRepoInTransaction(*TransactionContext, *pfs.InspectRepoRequest) (*pfs.RepoInfo, error)
    DeleteRepoInTransaction(*TransactionContext, *pfs.DeleteRepoRequest) error

    StartCommitInTransaction(*TransactionContext, *pfs.StartCommitRequest, *pfs.Commit) (*pfs.Commit, error)
    FinishCommitInTransaction(*TransactionContext, *pfs.FinishCommitRequest) error
    DeleteCommitInTransaction(*TransactionContext, *pfs.DeleteCommitRequest) error

    CreateBranchInTransaction(*TransactionContext, *pfs.CreateBranchRequest) error
    DeleteBranchInTransaction(*TransactionContext, *pfs.DeleteBranchRequest) error
}

PfsTransactionServer is an interface for the transactionally-supported methods that can be called through the PFS server.

type PfsWrites Uses

type PfsWrites interface {
    CreateRepo(*pfs.CreateRepoRequest) error
    DeleteRepo(*pfs.DeleteRepoRequest) error

    StartCommit(*pfs.StartCommitRequest, *pfs.Commit) (*pfs.Commit, error)
    FinishCommit(*pfs.FinishCommitRequest) error
    DeleteCommit(*pfs.DeleteCommitRequest) error

    CreateBranch(*pfs.CreateBranchRequest) error
    DeleteBranch(*pfs.DeleteBranchRequest) error
}

PfsWrites is an interface providing a wrapper for each operation that may be appended to a transaction through PFS. Each call may either directly run the request through PFS or append it to the active transaction, depending on if there is an active transaction in the client context.

type Transaction Uses

type Transaction interface {
    PfsWrites
    AuthWrites
}

Transaction is an interface to unify the code that may either perform an action directly or append an action to an existing transaction (depending on if there is an active transaction in the client context metadata). There are two implementations of this interface:

directTransaction: all operations will be run directly through the relevant
  server, all inside the same STM.
appendTransaction: all operations will be appended to the active transaction
  which will then be dryrun so that the response for the operation can be
  returned.  Each operation that is appended will do a new dryrun, so this
  isn't as efficient as it could be.

func NewDirectTransaction Uses

func NewDirectTransaction(txnCtx *TransactionContext) Transaction

NewDirectTransaction is a helper function to instantiate a directTransaction object. It is exposed so that the transaction API server can run a direct transaction even though there is an active transaction in the context (which is why it cannot use `WithTransaction`).

type TransactionContext Uses

type TransactionContext struct {
    ClientContext context.Context
    Client        *client.APIClient
    Stm           col.STM
    // contains filtered or unexported fields
}

TransactionContext is a helper type to encapsulate the state for a given set of operations being performed in the Pachyderm API. When a new transaction is started, a context will be created for it containing these objects, which will be threaded through to every API call:

ctx: the client context which initiated the operations being performed
pachClient: the APIClient associated with the client context ctx
stm: the object that controls transactionality with etcd.  This is to ensure
  that all reads and writes are consistent until changes are committed.
txnEnv: a struct containing references to each API server, it can be used
  to make calls to other API servers (e.g. checking auth permissions)
pfsDefer: an interface for ensuring certain PFS cleanup tasks are performed
  properly (and deduped) at the end of the transaction.

func (*TransactionContext) Auth Uses

func (t *TransactionContext) Auth() AuthTransactionServer

Auth returns a reference to the Auth API Server so that transactionally- supported methods can be called across the API boundary without using RPCs (which will not maintain transactional guarantees)

func (*TransactionContext) Pfs Uses

func (t *TransactionContext) Pfs() PfsTransactionServer

Pfs returns a reference to the PFS API Server so that transactionally- supported methods can be called across the API boundary without using RPCs (which will not maintain transactional guarantees)

func (*TransactionContext) PropagateCommit Uses

func (t *TransactionContext) PropagateCommit(branch *pfs.Branch, isNewCommit bool) error

PropagateCommit saves a branch to be propagated at the end of the transaction (if all operations complete successfully). This is used to batch together propagations and dedupe downstream commits in PFS.

type TransactionEnv Uses

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

TransactionEnv contains the APIServer instances for each subsystem that may be involved in running transactions so that they can make calls to each other without leaving the context of a transaction. This is a separate object because there are cyclic dependencies between APIServer instances.

func (*TransactionEnv) Initialize Uses

func (env *TransactionEnv) Initialize(
    serviceEnv *serviceenv.ServiceEnv,
    txnServer TransactionServer,
    authServer AuthTransactionServer,
    pfsServer PfsTransactionServer,
)

Initialize stores the references to APIServer instances in the TransactionEnv

func (*TransactionEnv) WithReadContext Uses

func (env *TransactionEnv) WithReadContext(ctx context.Context, cb func(*TransactionContext) error) error

WithReadContext will call the given callback with a TransactionContext which can be used to perform reads of the current cluster state. If the transaction is used to perform any writes, they will be silently discarded.

func (*TransactionEnv) WithTransaction Uses

func (env *TransactionEnv) WithTransaction(ctx context.Context, cb func(Transaction) error) error

WithTransaction will call the given callback with a txnenv.Transaction object, which is instantiated differently based on if an active transaction is present in the RPC context. If an active transaction is present, any calls into the Transaction are first dry-run then appended to the transaction. If there is no active transaction, the request will be run directly through the selected server.

func (*TransactionEnv) WithWriteContext Uses

func (env *TransactionEnv) WithWriteContext(ctx context.Context, cb func(*TransactionContext) error) error

WithWriteContext will call the given callback with a TransactionContext which can be used to perform reads and writes on the current cluster state.

type TransactionServer Uses

type TransactionServer interface {
    AppendRequest(
        context.Context,
        *transaction.Transaction,
        *transaction.TransactionRequest,
    ) (*transaction.TransactionResponse, error)
}

TransactionServer is an interface used by other servers to append a request to an existing transaction.

Package transactionenv imports 8 packages (graph) and is imported by 9 packages. Updated 2019-07-08. Refresh now. Tools for package owners.