txqueue

package
v0.0.0-...-953790c Latest Latest
Warning

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

 Go to latest Published: Jan 11, 2018 License: MPL-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// DefaultTxQueueCap defines how many items can be queued.
	DefaultTxQueueCap = int(35)
	// DefaultTxSendQueueCap defines how many items can be passed to sendTransaction() w/o blocking.
	DefaultTxSendQueueCap = int(70)
	// DefaultTxSendCompletionTimeout defines how many seconds to wait before returning result in sentTransaction().
	DefaultTxSendCompletionTimeout = 300
)
View Source 
const (
	// EventTransactionQueued is triggered when send transaction request is queued
	EventTransactionQueued = "transaction.queued"

	// EventTransactionFailed is triggered when send transaction request fails
	EventTransactionFailed = "transaction.failed"

	// SendTxDefaultErrorCode is sent by default, when error is not nil, but type is unknown/unexpected.
	SendTxDefaultErrorCode = SendTransactionDefaultErrorCode
)
View Source 
const (
	SendTransactionNoErrorCode        = "0"
	SendTransactionDefaultErrorCode   = "1"
	SendTransactionPasswordErrorCode  = "2"
	SendTransactionTimeoutErrorCode   = "3"
	SendTransactionDiscardedErrorCode = "4"
)

Send transaction response codes

Variables

View Source 
var (
	//ErrQueuedTxIDNotFound - error transaction hash not found
	ErrQueuedTxIDNotFound = errors.New("transaction hash not found")
	//ErrQueuedTxTimedOut - error transaction sending timed out
	ErrQueuedTxTimedOut = errors.New("transaction sending timed out")
	//ErrQueuedTxDiscarded - error transaction discarded
	ErrQueuedTxDiscarded = errors.New("transaction has been discarded")
	//ErrQueuedTxInProgress - error transaction in progress
	ErrQueuedTxInProgress = errors.New("transaction is in progress")
	//ErrQueuedTxAlreadyProcessed - error transaction has already processed
	ErrQueuedTxAlreadyProcessed = errors.New("transaction has been already processed")
	//ErrInvalidCompleteTxSender - error transaction with invalid sender
	ErrInvalidCompleteTxSender = errors.New("transaction can only be completed by the same account which created it")
)
View Source 
var ErrTxQueueRunFailure = errors.New("error running transaction queue")

ErrTxQueueRunFailure - error running transaction queue

Functions

func HaltOnPanic 

func HaltOnPanic()

HaltOnPanic recovers from panic, logs issue, sends upward notification, and exits

Types

type Manager 

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

Manager provides means to manage internal Status Backend (injected into LES)

func NewManager 

func NewManager(nodeManager common.NodeManager, accountManager common.AccountManager) *Manager

NewManager returns a new Manager.

func (*Manager) CompleteTransaction 

func (m *Manager) CompleteTransaction(id common.QueuedTxID, password string) (gethcommon.Hash, error)

CompleteTransaction instructs backend to complete sending of a given transaction. TODO(adam): investigate a possible bug that calling this method multiple times with the same Transaction ID results in sending multiple transactions.

func (*Manager) CompleteTransactions 

func (m *Manager) CompleteTransactions(ids []common.QueuedTxID, password string) map[common.QueuedTxID]common.RawCompleteTransactionResult

CompleteTransactions instructs backend to complete sending of multiple transactions

func (*Manager) CreateTransaction 

func (m *Manager) CreateTransaction(ctx context.Context, args common.SendTxArgs) *common.QueuedTx

CreateTransaction returns a transaction object.

func (*Manager) DiscardTransaction 

func (m *Manager) DiscardTransaction(id common.QueuedTxID) error

DiscardTransaction discards a given transaction from transaction queue

func (*Manager) DiscardTransactions 

func (m *Manager) DiscardTransactions(ids []common.QueuedTxID) map[common.QueuedTxID]common.RawDiscardTransactionResult

DiscardTransactions discards given multiple transactions from transaction queue

func (*Manager) NotifyOnQueuedTxReturn 

func (m *Manager) NotifyOnQueuedTxReturn(queuedTx *common.QueuedTx, err error)

NotifyOnQueuedTxReturn calls a handler when a transaction resolves.

func (*Manager) QueueTransaction 

func (m *Manager) QueueTransaction(tx *common.QueuedTx) error

QueueTransaction puts a transaction into the queue.

func (*Manager) SendTransactionRPCHandler 

func (m *Manager) SendTransactionRPCHandler(ctx context.Context, args ...interface{}) (interface{}, error)

SendTransactionRPCHandler is a handler for eth_sendTransaction method. It accepts one param which is a slice with a map of transaction params.

func (*Manager) SetTransactionQueueHandler 

func (m *Manager) SetTransactionQueueHandler(fn common.EnqueuedTxHandler)

SetTransactionQueueHandler sets a handler that will be called when a new transaction is enqueued.

func (*Manager) SetTransactionReturnHandler 

func (m *Manager) SetTransactionReturnHandler(fn common.EnqueuedTxReturnHandler)

SetTransactionReturnHandler sets a handler that will be called when a transaction is about to return or when a recoverable error occurred. Recoverable error is, for instance, wrong password.

func (*Manager) Start 

func (m *Manager) Start()

Start starts accepting new transactions into the queue.

func (*Manager) Stop 

func (m *Manager) Stop()

Stop stops accepting new transactions into the queue.

func (*Manager) TransactionQueue 

func (m *Manager) TransactionQueue() common.TxQueue

TransactionQueue returns a reference to the queue.

func (*Manager) TransactionQueueHandler 

func (m *Manager) TransactionQueueHandler() func(queuedTx *common.QueuedTx)

TransactionQueueHandler returns handler that processes incoming tx queue requests

func (*Manager) TransactionReturnHandler 

func (m *Manager) TransactionReturnHandler() func(queuedTx *common.QueuedTx, err error)

TransactionReturnHandler returns handler that processes responses from internal tx manager

func (*Manager) WaitForTransaction 

func (m *Manager) WaitForTransaction(tx *common.QueuedTx) error

WaitForTransaction adds a transaction to the queue and blocks until it's completed, discarded or times out.

type ReturnSendTransactionEvent 

type ReturnSendTransactionEvent struct {
	ID           string            `json:"id"`
	Args         common.SendTxArgs `json:"args"`
	MessageID    string            `json:"message_id"`
	ErrorMessage string            `json:"error_message"`
	ErrorCode    string            `json:"error_code"`
}

ReturnSendTransactionEvent is a JSON returned whenever transaction send is returned

type SendTransactionEvent 

type SendTransactionEvent struct {
	ID        string            `json:"id"`
	Args      common.SendTxArgs `json:"args"`
	MessageID string            `json:"message_id"`
}

SendTransactionEvent is a signal sent on a send transaction request

type TxQueue 

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

TxQueue is capped container that holds pending transactions

func NewTransactionQueue 

func NewTransactionQueue() *TxQueue

NewTransactionQueue make new transaction queue

func (*TxQueue) Count 

func (q *TxQueue) Count() int

Count returns number of currently queued transactions

func (*TxQueue) Enqueue 

func (q *TxQueue) Enqueue(tx *common.QueuedTx) error

Enqueue enqueues incoming transaction

func (*TxQueue) EnqueueAsync 

func (q *TxQueue) EnqueueAsync(tx *common.QueuedTx) error

EnqueueAsync enqueues incoming transaction in async manner, returns as soon as possible

func (*TxQueue) Get 

func (q *TxQueue) Get(id common.QueuedTxID) (*common.QueuedTx, error)

Get returns transaction by transaction identifier

func (*TxQueue) Has 

func (q *TxQueue) Has(id common.QueuedTxID) bool

Has checks whether transaction with a given identifier exists in queue

func (*TxQueue) NotifyOnQueuedTxReturn 

func (q *TxQueue) NotifyOnQueuedTxReturn(queuedTx *common.QueuedTx, err error)

NotifyOnQueuedTxReturn is invoked when transaction is ready to return Transaction can be in error state, or executed successfully at this point.

func (*TxQueue) Remove 

func (q *TxQueue) Remove(id common.QueuedTxID)

Remove removes transaction by transaction identifier

func (*TxQueue) Reset 

func (q *TxQueue) Reset()

Reset is to be used in tests only, as it simply creates new transaction map, w/o any cleanup of the previous one

func (*TxQueue) SetEnqueueHandler 

func (q *TxQueue) SetEnqueueHandler(fn common.EnqueuedTxHandler)

SetEnqueueHandler sets callback handler, that is triggered on enqueue operation

func (*TxQueue) SetTxReturnHandler 

func (q *TxQueue) SetTxReturnHandler(fn common.EnqueuedTxReturnHandler)

SetTxReturnHandler sets callback handler, that is triggered when transaction is finished executing

func (*TxQueue) Start 

func (q *TxQueue) Start()

Start starts enqueue and eviction loops

func (*TxQueue) StartProcessing 

func (q *TxQueue) StartProcessing(tx *common.QueuedTx) error

StartProcessing marks a transaction as in progress. It's thread-safe and prevents from processing the same transaction multiple times.

func (*TxQueue) Stop 

func (q *TxQueue) Stop()

Stop stops transaction enqueue and eviction loops

func (*TxQueue) StopProcessing 

func (q *TxQueue) StopProcessing(tx *common.QueuedTx)

StopProcessing removes the "InProgress" flag from the transaction.

Source Files

View all Source files

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.