lockservice

type Client interface {
	// Send send request to other lock service, and wait for a response synchronously.
	Send(context.Context, *pb.Request) (*pb.Response, error)
	// AsyncSend async send request to other lock service.
	AsyncSend(context.Context, *pb.Request) (*morpc.Future, error)
	// Close close the client
	Close() error
}

type Config struct {
	// ServiceID service id
	ServiceID string `toml:"-"`
	// RPC rpc config
	RPC morpc.Config `toml:"-"`

	// TxnIterFunc used to iterate all active transactions in current cn
	TxnIterFunc func(func([]byte) bool) `toml:"-"`

	// ListenAddress lock service listen address for receiving lock requests
	ListenAddress string `toml:"listen-address"`
	// ServiceAddress service address for communication, if this address is not set, use
	// ListenAddress as the communication address.
	ServiceAddress string `toml:"service-address"`
	// MaxFixedSliceSize lockservice uses fixedSlice to store all lock information, a pool
	// of fixedSlice will be built internally, there are various specifications of fixexSlice,
	// this value sets how big the maximum specification of FixedSlice is.
	MaxFixedSliceSize toml.ByteSize `toml:"max-fixed-slice-size"`
	// KeepBindDuration Maintain the period of the locktable bound to the current service
	KeepBindDuration toml.Duration `toml:"keep-bind-duration"`
	// KeepRemoteLockDuration how often to send a heartbeat to maintain a lock on a remote
	// locktable.
	KeepRemoteLockDuration toml.Duration `toml:"keep-remote-lock-duration"`
	// RemoteLockTimeout how long does it take to receive a heartbeat that maintains the
	// remote lock before releasing the lock
	RemoteLockTimeout toml.Duration `toml:"remote-lock-timeout"`
	// MaxLockRowCount each time a lock is added, some LockRow is stored in the lockservice, if
	// too many LockRows are put in each time, it will cause too much memory overhead, this value
	// limits the maximum count of LocRow put into the LockService each time, beyond this value it
	// will be converted into a Range of locks
	MaxLockRowCount toml.ByteSize `toml:"max-row-lock-count"`
	// KeepBindTimeout when a locktable is assigned to a lockservice, the lockservice will
	// continuously hold the bind, and if no hold request is received after the configured time,
	// then all bindings for the service will fail.
	KeepBindTimeout toml.Duration `toml:"keep-bind-timeout"`
	// contains filtered or unexported fields
}

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

type LockOptions struct {
	pb.LockOptions
	// contains filtered or unexported fields
}

type LockService interface {
	// GetServiceID return service id
	GetServiceID() string
	// GetConfig returns the lockservice config
	GetConfig() Config
	// Lock locks rows(row or row range determined by the Granularity in options) a table. Lockservice
	// has no requirement for the format of rows, but requires all rows of a table on a lockservice
	// to be sortable.
	//
	// If a conflict is encountered, the method will block until the conflicting lock is
	// released and held by the current operation, or until it times out.
	//
	// Returns false if conflicts are encountered in FastFail wait policy and ErrDeadLockDetected
	// returns if current operation was aborted by deadlock detection.
	Lock(ctx context.Context, tableID uint64, rows [][]byte, txnID []byte, options pb.LockOptions) (pb.Result, error)
	// Unlock release all locks associated with the transaction. If commitTS is not empty, means
	// the txn was committed.
	Unlock(ctx context.Context, txnID []byte, commitTS timestamp.Timestamp) error

	// Close close the lock service.
	Close() error

	// GetWaitingList get special txnID's waiting list
	GetWaitingList(ctx context.Context, txnID []byte) (bool, []pb.WaitTxn, error)
	// ForceRefreshLockTableBinds force refresh all lock tables binds
	ForceRefreshLockTableBinds(targets []uint64, matcher func(bind pb.LockTable) bool)
	// GetLockTableBind returns lock table bind
	GetLockTableBind(tableID uint64) (pb.LockTable, error)
	// IterLocks iter all locks on current lock service. len(keys) == 2 if is range lock,
	// len(keys) == 1 if is row lock. And keys only valid in current iter func call.
	IterLocks(func(tableID uint64, keys [][]byte, lock Lock) bool)
	// CloseRemoteLockTable close lock table
	CloseRemoteLockTable(tableID, version uint64) (bool, error)
}

type LockStorage interface {
	// Add we use kv to store the lock. Key is a locked row or a row range. Value is the
	// TxnID.
	Add(key []byte, value Lock)
	// Get returns the value of the given key
	Get(key []byte) (Lock, bool)
	// Len returns number of the locks in the storage
	Len() int
	// Delete delete lock from the storage
	Delete(key []byte) (Lock, bool)
	// Seek returns the first KV Pair that is >= the given key
	Seek(key []byte) ([]byte, Lock, bool)
	// Prev returns the first KV Pair that is < the given key
	Prev(key []byte) ([]byte, Lock, bool)
	// Range range in [start, end), if end == nil, no upperBounded
	Range(start []byte, end []byte, fn func([]byte, Lock) bool)
	// Iter iter all values
	Iter(func([]byte, Lock) bool)
	// Clear clear the lock
	Clear()
}

type LockTableAllocator interface {
	// Get get the original LockTable data corresponding to a Table. If there is no
	// corresponding binding, then the CN binding of the current request will be used.
	Get(serviceID string, tableID uint64) pb.LockTable
	// KeepLockTableBind once a cn is bound to a Table, a heartbeat needs to be sent
	// periodically to keep the binding in place. If no heartbeat is sent for a long
	// period of time to maintain the binding, the binding will become invalid.
	KeepLockTableBind(serviceID string) bool
	// Valid check for changes in the binding relationship of a specific locktable.
	Valid(serviceID string, txnID []byte, binds []pb.LockTable) ([]uint64, error)
	// AddCannotCommit add cannot commit txn
	AddCannotCommit(values []pb.OrphanTxn)
	// Close close the lock table allocator
	Close() error

	// GetLatest get latest lock table bind
	GetLatest(tableID uint64) pb.LockTable
}

type LockTableKeeper interface {
	// Close close the keeper
	Close() error
}

type RequestHandleFunc func(context.Context, context.CancelFunc, *pb.Request, *pb.Response, morpc.ClientSession)

type Server interface {
	// Start start the txn server
	Start() error
	// Close the txn server
	Close() error
	// RegisterMethodHandler register txn request handler func
	RegisterMethodHandler(pb.Method, RequestHandleFunc)
}

type ServerOption func(*server)