curator

type ACLProvider interface {
	// Return the ACL list to use by default
	GetDefaultAcl() []zk.ACL

	// Return the ACL list to use for the given path
	GetAclForPath(path string) []zk.ACL
}

type AtomicBool int32

type AuthInfo struct {
	Scheme string
	Auth   []byte
}

type BackgroundCallback func(client CuratorFramework, event CuratorEvent) error

type CheckExistsBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) (*zk.Stat, error)

	// Watchable[T]
	//
	// Have the operation set a watch
	Watched() CheckExistsBuilder

	// Set a watcher for the operation
	UsingWatcher(watcher Watcher) CheckExistsBuilder

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() CheckExistsBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) CheckExistsBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) CheckExistsBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) CheckExistsBuilder
}

type Closeable interface {
	// Closes this and releases any system resources associated with it.
	Close() error
}

type CompressionProvider interface {
	Compress(path string, data []byte) ([]byte, error)

	Decompress(path string, compressedData []byte) ([]byte, error)
}

type ConnectionState int32

type ConnectionStateListenable interface {
	Listenable /* [T] */

	AddListener(listener ConnectionStateListener)

	RemoveListener(listener ConnectionStateListener)
}

type ConnectionStateListener interface {
	// Called when there is a state change in the connection
	StateChanged(client CuratorFramework, newState ConnectionState)
}

type CreateBuilder interface {
	// PathAndBytesable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) (string, error)

	// Commit the currently building operation using the given path and data
	ForPathWithData(path string, payload []byte) (string, error)

	// ParentsCreatable[T]
	//
	// Causes any parent nodes to get created if they haven't already been
	CreatingParentsIfNeeded() CreateBuilder

	// CreateModable[T]
	//
	// Set a create mode - the default is CreateMode.PERSISTENT
	WithMode(mode CreateMode) CreateBuilder

	// ACLable[T]
	//
	// Set an ACL list
	WithACL(acls ...zk.ACL) CreateBuilder

	// Compressible[T]
	//
	// Cause the data to be compressed using the configured compression provider
	Compressed() CreateBuilder

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() CreateBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) CreateBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) CreateBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) CreateBuilder
}

type CreateMode int32

type CuratorEvent interface {
	// check here first - this value determines the type of event and which methods will have valid values
	Type() CuratorEventType

	// "rc" from async callbacks
	Err() error

	// the path
	Path() string

	// the context object passed to Backgroundable.InBackground(interface{})
	Context() interface{}

	// any stat
	Stat() *zk.Stat

	// any data
	Data() []byte

	// any name
	Name() string

	// any children
	Children() []string

	// any ACL list or null
	ACLs() []zk.ACL

	WatchedEvent() *zk.Event
}

type CuratorEventType int

type CuratorFramework interface {
	// Start the client.
	// Most mutator methods will not work until the client is started
	Start() error

	// Stop the client
	Close() error

	// Returns the state of this instance
	State() State

	// Return true if the client is started, not closed, etc.
	Started() bool

	// Start a create builder
	Create() CreateBuilder

	// Start a delete builder
	Delete() DeleteBuilder

	// Start an exists builder
	CheckExists() CheckExistsBuilder

	// Start a get data builder
	GetData() GetDataBuilder

	// Start a set data builder
	SetData() SetDataBuilder

	// Start a get children builder
	GetChildren() GetChildrenBuilder

	// Start a get ACL builder
	GetACL() GetACLBuilder

	// Start a set ACL builder
	SetACL() SetACLBuilder

	// Start a transaction builder
	InTransaction() Transaction

	// Perform a sync on the given path - syncs are always in the background
	DoSync(path string, backgroundContextObject interface{})

	//  Start a sync builder. Note: sync is ALWAYS in the background even if you don't use one of the background() methods
	Sync() SyncBuilder

	// Returns the listenable interface for the Connect State
	ConnectionStateListenable() ConnectionStateListenable

	// Returns the listenable interface for events
	CuratorListenable() CuratorListenable

	// Returns the listenable interface for unhandled errors
	UnhandledErrorListenable() UnhandledErrorListenable

	// Returns a facade of the current instance that does _not_ automatically pre-pend the namespace to all paths
	NonNamespaceView() CuratorFramework

	// Returns a facade of the current instance that uses the specified namespace
	// or no namespace if newNamespace is empty.
	UsingNamespace(newNamespace string) CuratorFramework

	// Return the current namespace or "" if none
	Namespace() string

	// Return the managed zookeeper client
	ZookeeperClient() CuratorZookeeperClient

	// Allocates an ensure path instance that is namespace aware
	NewNamespaceAwareEnsurePath(path string) EnsurePath

	// Block until a connection to ZooKeeper is available.
	BlockUntilConnected() error

	// Block until a connection to ZooKeeper is available or the maxWaitTime has been exceeded
	BlockUntilConnectedTimeout(maxWaitTime time.Duration) error
}

type CuratorFrameworkBuilder struct {
	AuthInfos           []AuthInfo          // the connection authorization
	ZookeeperDialer     ZookeeperDialer     // the zookeeper dialer to use
	EnsembleProvider    EnsembleProvider    // the list ensemble provider.
	DefaultData         []byte              // the data to use when PathAndBytesable.ForPath(String) is used.
	Namespace           string              // as ZooKeeper is a shared space, users of a given cluster should stay within a pre-defined namespace
	SessionTimeout      time.Duration       // the session timeout
	ConnectionTimeout   time.Duration       // the connection timeout
	MaxCloseWait        time.Duration       // the time to wait during close to wait background tasks
	RetryPolicy         RetryPolicy         // the retry policy to use
	CompressionProvider CompressionProvider // the compression provider
	AclProvider         ACLProvider         // the provider for ACLs
	CanBeReadOnly       bool                // allow ZooKeeper client to enter read only mode in case of a network partition.
}

type CuratorListenable interface {
	Listenable /* [T] */

	AddListener(listener CuratorListener)

	RemoveListener(listener CuratorListener)
}

type CuratorListener interface {
	// Called when a background task has completed or a watch has triggered
	EventReceived(client CuratorFramework, event CuratorEvent) error
}

type CuratorZookeeperClient interface {
	// Return the managed ZK connection.
	Conn() (ZookeeperConnection, error)

	// Return the current retry policy
	RetryPolicy() RetryPolicy

	// Return a new retry loop. All operations should be performed in a retry loop
	NewRetryLoop() RetryLoop

	// Returns true if the client is current connected
	Connected() bool

	// This method blocks until the connection to ZK succeeds.
	BlockUntilConnectedOrTimedOut() error

	// Must be called after created
	Start() error

	// Close the client
	Close() error

	// Start a new tracer
	StartTracer(name string) Tracer
}

type DefaultZookeeperDialer struct {
	Dialer zk.Dialer
}

type DeleteBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) error

	// ChildrenDeletable[T]
	//
	// Will also delete children if they exist.
	DeletingChildrenIfNeeded() DeleteBuilder

	// Versionable[T]
	//
	// Use the given version (the default is -1)
	WithVersion(version int32) DeleteBuilder

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() DeleteBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) DeleteBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) DeleteBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) DeleteBuilder
}

type EnsembleProvider interface {
	// Curator will call this method when CuratorZookeeperClient.Start() is called
	Start() error

	// Curator will call this method when CuratorZookeeperClient.Close() is called
	Close() error

	// Return the current connection string to use
	ConnectionString() string
}

type EnsurePath interface {
	// First time, synchronizes and makes sure all nodes in the path are created.
	// Subsequent calls with this instance are NOPs.
	Ensure(client CuratorZookeeperClient) error

	// Returns a view of this EnsurePath instance that does not make the last node.
	ExcludingLast() EnsurePath
}

type EnsurePathHelper interface {
	Ensure(client CuratorZookeeperClient, path string, makeLastNode bool) error
}

type ExponentialBackoffRetry struct {
	SleepingRetry
}

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

type GetACLBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) ([]zk.ACL, error)

	// Statable[T]
	//
	// Have the operation fill the provided stat object
	StoringStatIn(stat *zk.Stat) GetACLBuilder

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() GetACLBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) GetACLBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) GetACLBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) GetACLBuilder
}

type GetChildrenBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) ([]string, error)

	// Statable[T]
	//
	// Have the operation fill the provided stat object
	StoringStatIn(stat *zk.Stat) GetChildrenBuilder

	// Watchable[T]
	//
	// Have the operation set a watch
	Watched() GetChildrenBuilder

	// Set a watcher for the operation
	UsingWatcher(watcher Watcher) GetChildrenBuilder

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() GetChildrenBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) GetChildrenBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) GetChildrenBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) GetChildrenBuilder
}

type GetDataBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) ([]byte, error)

	// Decompressible[T]
	//
	// Cause the data to be de-compressed using the configured compression provider
	Decompressed() GetDataBuilder

	// Statable[T]
	//
	// Have the operation fill the provided stat object
	StoringStatIn(stat *zk.Stat) GetDataBuilder

	// Watchable[T]
	//
	// Have the operation set a watch
	Watched() GetDataBuilder

	// Set a watcher for the operation
	UsingWatcher(watcher Watcher) GetDataBuilder

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() GetDataBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) GetDataBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) GetDataBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) GetDataBuilder
}

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

type LZ4CompressionProvider struct{}

type Listenable interface {
	Len() int

	Clear()

	ForEach(callback func(interface{}))
}

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

type OperationType int

type PathAndNode struct {
	Path, Node string
}

type RetryLoop interface {
	// creates a retry loop calling the given proc and retrying if needed
	CallWithRetry(proc func() (interface{}, error)) (interface{}, error)
}

type RetryNTimes struct {
	SleepingRetry
}

type RetryOneTime struct {
	RetryNTimes
}

type RetryPolicy interface {
	// Called when an operation has failed for some reason.
	// This method should return true to make another attempt.
	AllowRetry(retryCount int, elapsedTime time.Duration, sleeper RetrySleeper) bool
}

type RetrySleeper interface {
	// Sleep for the given time
	SleepFor(time time.Duration) error
}

type RetryUntilElapsed struct {
	SleepingRetry
	// contains filtered or unexported fields
}

type SetACLBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) (*zk.Stat, error)

	// ACLable[T]
	//
	// Set an ACL list
	WithACL(acls ...zk.ACL) SetACLBuilder

	// Versionable[T]
	//
	// Use the given version (the default is -1)
	WithVersion(version int32) SetACLBuilder

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() SetACLBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) SetACLBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) SetACLBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) SetACLBuilder
}

type SetDataBuilder interface {
	// PathAndBytesable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) (*zk.Stat, error)

	// Commit the currently building operation using the given path and data
	ForPathWithData(path string, payload []byte) (*zk.Stat, error)

	// Versionable[T]
	//
	// Use the given version (the default is -1)
	WithVersion(version int32) SetDataBuilder

	// Compressible[T]
	//
	// Cause the data to be compressed using the configured compression provider
	Compressed() SetDataBuilder

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() SetDataBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) SetDataBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) SetDataBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) SetDataBuilder
}

type SleepingRetry struct {
	RetryPolicy

	N int
	// contains filtered or unexported fields
}

type State int32

type SyncBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) (string, error)

	// Backgroundable[T]
	//
	// Perform the action in the background
	InBackground() SyncBuilder

	// Perform the action in the background
	InBackgroundWithContext(context interface{}) SyncBuilder

	// Perform the action in the background
	InBackgroundWithCallback(callback BackgroundCallback) SyncBuilder

	// Perform the action in the background
	InBackgroundWithCallbackAndContext(callback BackgroundCallback, context interface{}) SyncBuilder
}

type Tracer interface {
	Commit()
}

type TracerDriver interface {
	// Record the given trace event
	AddTime(name string, d time.Duration)

	// Add to a named counter
	AddCount(name string, increment int)
}

type Transaction interface {
	// Start a create builder in the transaction
	Create() TransactionCreateBuilder

	// Start a delete builder in the transaction
	Delete() TransactionDeleteBuilder

	// Start a set data builder in the transaction
	SetData() TransactionSetDataBuilder

	// Start a check builder in the transaction
	Check() TransactionCheckBuilder
}

type TransactionBridge interface {
	TransactionFinal

	And() TransactionFinal
}

type TransactionCheckBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) TransactionBridge

	// Versionable[T]
	//
	// Use the given version (the default is -1)
	WithVersion(version int32) TransactionCheckBuilder
}

type TransactionCreateBuilder interface {
	// PathAndBytesable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) TransactionBridge

	// Commit the currently building operation using the given path and data
	ForPathWithData(path string, payload []byte) TransactionBridge

	// CreateModable[T]
	//
	// Set a create mode - the default is CreateMode.PERSISTENT
	WithMode(mode CreateMode) TransactionCreateBuilder

	// ACLable[T]
	//
	// Set an ACL list
	WithACL(acls ...zk.ACL) TransactionCreateBuilder

	// Compressible[T]
	//
	// Cause the data to be compressed using the configured compression provider
	Compressed() TransactionCreateBuilder
}

type TransactionDeleteBuilder interface {
	// Pathable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) TransactionBridge

	// Versionable[T]
	//
	// Use the given version (the default is -1)
	WithVersion(version int32) TransactionDeleteBuilder
}

type TransactionFinal interface {
	Transaction

	// Commit all added operations as an atomic unit and return results for the operations.
	// One result is returned for each operation added.
	// Further, the ordering of the results matches the ordering that the operations were added.
	Commit() ([]TransactionResult, error)
}

type TransactionResult struct {
	Type       OperationType
	ForPath    string
	ResultPath string
	ResultStat *zk.Stat
}

type TransactionSetDataBuilder interface {
	// PathAndBytesable[T]
	//
	// Commit the currently building operation using the given path
	ForPath(path string) TransactionBridge

	// Commit the currently building operation using the given path and data
	ForPathWithData(path string, payload []byte) TransactionBridge

	// Versionable[T]
	//
	// Use the given version (the default is -1)
	WithVersion(version int32) TransactionSetDataBuilder

	// Compressible[T]
	//
	// Cause the data to be compressed using the configured compression provider
	Compressed() TransactionSetDataBuilder
}

type UnhandledErrorListenable interface {
	Listenable /* [T] */

	AddListener(listener UnhandledErrorListener)

	RemoveListener(listener UnhandledErrorListener)
}

type UnhandledErrorListener interface {
	// Called when an exception is caught in a background thread, handler, etc.
	UnhandledError(err error)
}

type Watcher interface {
	// contains filtered or unexported methods
}

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

type ZookeeperConnection interface {
	// Add the specified scheme:auth information to this connection.
	AddAuth(scheme string, auth []byte) error

	// Close this connection
	Close()

	// Create a node with the given path.
	//
	// The node data will be the given data, and node acl will be the given acl.
	Create(path string, data []byte, flags int32, acl []zk.ACL) (string, error)

	// Return the stat of the node of the given path. Return nil if no such a node exists.
	Exists(path string) (bool, *zk.Stat, error)

	ExistsW(path string) (bool, *zk.Stat, <-chan zk.Event, error)

	// Delete the node with the given path.
	//
	// The call will succeed if such a node exists,
	// and the given version matches the node's version
	// (if the given version is -1, it matches any node's versions).
	Delete(path string, version int32) error

	// Return the data and the stat of the node of the given path.
	Get(path string) ([]byte, *zk.Stat, error)

	GetW(path string) ([]byte, *zk.Stat, <-chan zk.Event, error)

	// Set the ACL for the node of the given path
	// if such a node exists and the given version matches the version of the node.
	// Return the stat of the node.
	Set(path string, data []byte, version int32) (*zk.Stat, error)

	// Return the list of the children of the node of the given path.
	Children(path string) ([]string, *zk.Stat, error)

	ChildrenW(path string) ([]string, *zk.Stat, <-chan zk.Event, error)

	// Return the ACL and stat of the node of the given path.
	GetACL(path string) ([]zk.ACL, *zk.Stat, error)

	// Set the ACL for the node of the given path
	// if such a node exists and the given version matches the version of the node.
	// Return the stat of the node.
	SetACL(path string, acl []zk.ACL, version int32) (*zk.Stat, error)

	// Executes multiple ZooKeeper operations or none of them.
	Multi(ops ...interface{}) ([]zk.MultiResponse, error)

	// Flushes channel between process and leader.
	Sync(path string) (string, error)
}

type ZookeeperDialFunc func(connString string, sessionTimeout time.Duration, canBeReadOnly bool) (ZookeeperConnection, <-chan zk.Event, error)

type ZookeeperDialer interface {
	Dial(connString string, sessionTimeout time.Duration, canBeReadOnly bool) (ZookeeperConnection, <-chan zk.Event, error)
}