txn

type CleanAndPruneArgs struct {

	// Txns is the collection that holds all of the transactions that we
	// might want to prune. We will also make use of Txns.Database to find
	// all of the collections that might make use of transactions from that
	// collection.
	Txns *mgo.Collection

	// TxnsCount is a hint from Txns.Count() to avoid having to call it again
	// to determine whether it is ok to hold the set of transactions in memory.
	// It is optional, as we will call Txns.Count() if it is not supplied.
	TxnsCount int

	// MaxTime is a timestamp that provides a threshold of transactions
	// that we will actually prune. Only transactions that were created
	// before this threshold will be pruned.
	MaxTime time.Time

	// MaxTransactionsToProcess defines how many completed transactions that we will evaluate in this batch.
	// A value of 0 indicates we should evaluate all completed transactions.
	MaxTransactionsToProcess int

	// Multithreaded will start multiple pruning passes concurrently
	Multithreaded bool

	// TxnBatchSize is how many transaction to process at once.
	TxnBatchSize int

	// TxnBatchSleepTime is how long we should sleep between processing transaction
	// batches, to allow other parts of the system to operate (avoid consuming
	// all resources)
	// The default is to not sleep at all, but this can be configured to reduce
	// load while pruning.
	TxnBatchSleepTime time.Duration
}

type CleanupStats struct {

	// CollectionsInspected is the total number of collections we looked at for documents
	CollectionsInspected int

	// DocsInspected is how many documents we loaded to evaluate their txn queues
	DocsInspected int

	// DocsCleaned is how many documents we Updated to remove entries from their txn queue.
	DocsCleaned int

	// StashDocumentsRemoved is how many total documents we remove from txns.stash
	StashDocumentsRemoved int

	// StashDocumentsRemoved is how many documents we remove from txns
	TransactionsRemoved int

	// ShouldRetry indicates that we think this cleanup was not complete due to too many txns to process. We recommend running it again.
	ShouldRetry bool
}

type Clock interface {
	// Now returns the current clock time.
	Now() time.Time
}

type CollectionConfig struct {
	// Oracle is an Oracle that we can use to determine if a given
	// transaction token should be considered a 'completed' transaction.
	Oracle Oracle

	// Source is the mongo collection holding documents created and managed
	// by transactions.
	Source *mgo.Collection

	// NumBatchTokens is the number of tokens that we will cache before
	// doing a query to find out whether their referenced transactions are
	// completed. It is useful to have a number in the hundreds so that we
	// efficiently query the mongo transaction database.
	NumBatchTokens int

	// MaxRemoveQueue is the maximum number of document ids that we will
	// hold on to in memory before we go back to the database to purge those
	// documents. This only affects StashCollectionCleaner, as the generic
	// cleaner never removes documents.
	MaxRemoveQueue int

	// LogInterval defines how often we will show progress
	LogInterval time.Duration
}

type CollectionStats struct {

	// DocCount is the total number of documents evaluated.
	DocCount int

	// TokenCount is the total number of transaction tokens that were
	// referenced by the documents.
	TokenCount int

	// CompletedTokenCount is the number of unique tokens that referenced
	// completed transactions.
	CompletedTokenCount int

	// CompletedTxnCount is the number of completed transactions that we
	// looked up.
	CompletedTxnCount int

	// UpdatedDocCount is the number of documents we modified without
	// removing them
	UpdatedDocCount int

	// PulledCount is the number of tokens that were removed from documents.
	PulledTokenCount int

	// RemovedCount represents the number of txns.stash documents that we
	// decided to remove entirely.
	RemovedCount int
}

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

type IncrementalPruneArgs struct {
	// MaxTime is a timestamp that provides a threshold of transactions
	// that we will actually prune. Only transactions that were created
	// before this threshold will be pruned.
	// MaxTime can be set to the Zero value to indicate all transactions.
	MaxTime time.Time

	// If ProgressChannel is not nil, this will send updates when documents are
	// processed and transactions are pruned.
	ProgressChannel chan ProgressMessage

	// ReverseOrder indicates we should process transactions from newest to
	// oldest instead of form oldest to newest.
	ReverseOrder bool

	// TxnBatchSize is how many transactions to process at once.
	TxnBatchSize int

	// TxnBatchSleepTime is how long we should sleep between processing transaction
	// batches, to allow other parts of the system to operate (avoid consuming
	// all resources)
	// The default is to not sleep at all, but this can be configured to reduce
	// load while pruning.
	TxnBatchSleepTime time.Duration
}

type IncrementalPruner struct {
	ProgressChan chan ProgressMessage
	// contains filtered or unexported fields
}

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

type Oracle interface {
	// Count returns the number of transactions that we are working with
	Count() int

	// CompletedTokens is called with a list of tokens to be checked. The
	// returned map will have a 'true' for any token that references a
	// completed transaction.
	CompletedTokens(tokens []string) (map[string]bool, error)

	// RemoveTxns can be used to flag that a given transaction should not
	// be considered part of the valid set.
	RemoveTxns(txnIds []bson.ObjectId) (int, error)

	// IterTxns lets you iterate over all of the transactions that have
	// not been removed.
	IterTxns() (OracleIterator, error)
}

type OracleIterator interface {
	// Grab the next transaction id. Will return nil if there are no
	// more transactions.
	Next() (bson.ObjectId, error)
}

type ProgressMessage struct {
	TxnsRemoved int
	DocsCleaned int
}

type PruneOptions struct {

	// PruneFactor will trigger a prune when the current count of
	// transactions in the database is greater than old*PruneFactor
	PruneFactor float32

	// MinNewTransactions will skip a prune even if pruneFactor is true
	// if there are less than MinNewTransactions that might be cleaned up.
	MinNewTransactions int

	// MaxNewTransactions will force a prune if it sees more than
	// MaxNewTransactions since the last run.
	MaxNewTransactions int

	// MaxTime sets a threshold for 'completed' transactions. Transactions
	// will be considered completed only if they are both older than
	// MaxTime and have a status of Completed or Aborted. Passing the
	// zero Time will cause us to only filter on the Status field.
	MaxTime time.Time

	// MaxBatchTransactions is the most transactions that we will prune in a single pass.
	// It is possible to pass 0 to prune all transactions in a pass. Note
	// that MaybePruneTransactions will always process all transactions, it
	// is just whether we do so in multiple passes, or whether it is done
	// all at once.
	MaxBatchTransactions int

	// MaxBatches is the maximum number of passes we will attempt. 0 or
	// negative values are treated as do a single pass.
	MaxBatches int

	// SmallBatchTransactionCount is the number of transactions to read at a time.
	// A value of 1000 seems to be a good balance between how much time we spend
	// processing, and how many documents we evaluate at one time. (a value of
	// 100 empirically processes slower, and a value of 10,000 wasn't any faster)
	SmallBatchTransactionCount int

	// BatchTransactionSleepTime is an amount of time that we will sleep between
	// processing batches of transactions. This allows us to avoid excess load
	// on the system while pruning.
	BatchTransactionSleepTime time.Duration
}

type PrunerStats struct {
	CacheLookupTime    time.Duration
	DocReadTime        time.Duration
	DocLookupTime      time.Duration
	DocCleanupTime     time.Duration
	StashLookupTime    time.Duration
	StashRemoveTime    time.Duration
	TxnReadTime        time.Duration
	TxnRemoveTime      time.Duration
	DocCacheHits       int64
	DocCacheMisses     int64
	DocMissingCacheHit int64
	DocsMissing        int64
	CollectionQueries  int64
	DocReads           int64
	DocStillMissing    int64
	StashQueries       int64
	StashDocReads      int64
	StashDocsRemoved   int64
	DocQueuesCleaned   int64
	DocTokensCleaned   int64
	DocsAlreadyClean   int64
	TxnsRemoved        int64
	TxnsNotRemoved     int64
	StrCacheHits       int64
	StrCacheMisses     int64
}

type Remover interface {
	Remove(id interface{}) error
	Flush() error
	Removed() int
}

type Runner interface {
	// RunTransaction applies the specified transaction operations to a database.
	RunTransaction(*Transaction) error

	// Run calls the nominated function to get the transaction operations to apply to a database.
	// If there is a failure due to a txn.ErrAborted error, the attempt is retried up to nrRetries times.
	Run(transactions TransactionSource) error

	// ResumeTransactions resumes all pending transactions.
	ResumeTransactions() error

	// MaybePruneTransactions removes data for completed transactions
	// from mgo/txn's transaction collection. It is intended to be
	// called periodically.
	//
	// Pruning is an I/O heavy activity so it will only be undertaken
	// if:
	//
	//   txn_count >= pruneFactor * txn_count_at_last_prune
	//
	MaybePruneTransactions(pruneOpts PruneOptions) error
}

type RunnerParams struct {
	// Database is the mgo database for which the transaction runner will be used.
	Database *mgo.Database

	// TransactionCollectionName is the name of the collection
	// used to initialise the underlying mgo transaction runner,
	// defaults to "txns" if unspecified.
	TransactionCollectionName string

	// ChangeLogName is the mgo transaction runner change log,
	// defaults to "txns.log" if unspecified.
	ChangeLogName string

	// RunTransactionObserver, if non-nil, will be called when
	// a Run or RunTransaction call has completed. It will be
	// passed the txn.Ops and the error result.
	RunTransactionObserver func(Transaction)

	// Clock is an optional clock to use. If Clock is nil, clock.WallClock will
	// be used.
	Clock Clock

	// ServerSideTransactions indicates that if SSTXNs are available, use them.
	// Note that we will check if they are supported server side, and fall
	// back to client-side transactions if they are not supported.
	ServerSideTransactions bool
}

type TestHook struct {
	Before func()
	After  func()
}

type Transaction struct {
	// Ops is the operations that were performed
	Ops []txn.Op
	// Error is the error returned from running the operation, might be nil
	Error error
	// Duration is length of time it took to run the operation
	Duration time.Duration
	// Attempt is the current attempt to apply the operation.
	Attempt int
}

type TransactionSource func(attempt int) ([]txn.Op, error)