zetcd

type ACL struct {
	Perms  int32
	Scheme string
	ID     string
}

type AuthConn interface {
	Read() (*AuthRequest, error)
	Write(AuthResponse) (Conn, error)
	Close()
}

type AuthFunc func(AuthConn) (Session, error)

type AuthRequest struct {
	Req            *ConnectRequest
	FourLetterWord string
}

type AuthResponse struct {
	Resp           *ConnectResponse
	FourLetterWord string
}

type CheckVersionRequest pathVersionRequest

type Client interface {
	Send(xid Xid, req interface{}) error
	Read() <-chan ZKResponse
	StopNotify() <-chan struct{}
	Close()
}

type CloseRequest struct{}

type CloseResponse struct{}

type Conn interface {
	Send(xid Xid, zxid ZXid, resp interface{}) error
	Read() <-chan ZKRequest
	StopNotify() <-chan struct{}
	Close()
}

type ConnectRequest struct {
	ProtocolVersion int32
	LastZxidSeen    ZXid
	TimeOut         int32
	SessionID       Sid
	Passwd          []byte
}

type ConnectResponse struct {
	ProtocolVersion int32
	TimeOut         int32
	SessionID       Sid
	Passwd          []byte
}

type CreateRequest struct {
	Path  string
	Data  []byte
	Acl   []ACL
	Flags int32
}

type CreateResponse pathResponse

type DeleteRequest pathVersionRequest

type DeleteResponse struct{}

type ErrCode int32

type EventType int32

type ExistsRequest pathWatchRequest

type ExistsResponse statResponse

type GetAclRequest pathRequest

type GetAclResponse struct {
	Acl  []ACL
	Stat Stat
}

type GetChildren2Request pathWatchRequest

type GetChildren2Response struct {
	Children []string
	Stat     Stat
}

type GetChildrenRequest pathWatchRequest

type GetChildrenResponse struct {
	Children []string
}

type GetDataRequest pathWatchRequest

type GetDataResponse struct {
	Data []byte
	Stat Stat
}

type MultiHeader struct {
	Type Op
	Done bool
	Err  ErrCode
}

type MultiRequest struct {
	Ops        []MultiRequestOp
	DoneHeader MultiHeader
}

type MultiRequestOp struct {
	Header MultiHeader
	Op     interface{}
}

type MultiResponse struct {
	Ops        []MultiResponseOp
	DoneHeader MultiHeader
}

type MultiResponseOp struct {
	Header MultiHeader
	String string
	Stat   *Stat
}

type Op int32

type PingRequest struct{}

type PingResponse struct{}

type ResponseHeader struct {
	Xid  Xid
	Zxid ZXid
	Err  ErrCode
}

type Session interface {
	Conn
	Watches
	Sid() Sid
	ZXid() ZXid
	ConnReq() ConnectRequest
	Backing() interface{}
}

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

type SetAclRequest struct {
	Path    string
	Acl     []ACL
	Version Ver
}

type SetAclResponse statResponse

type SetAuthRequest auth

type SetAuthResponse struct{}

type SetDataRequest struct {
	Path    string
	Data    []byte
	Version Ver
}

type SetDataResponse statResponse

type SetWatchesRequest struct {
	RelativeZxid ZXid
	DataWatches  []string
	ExistWatches []string
	ChildWatches []string
}

type SetWatchesResponse struct{}

type Sid int64

type Stat struct {
	// Czxid is the zxid change that caused this znode to be created.
	Czxid ZXid
	// Mzxid is The zxid change that last modified this znode.
	Mzxid ZXid
	// Ctime is milliseconds from epoch when this znode was created.
	Ctime int64
	// Mtime is The time in milliseconds from epoch when this znode was last modified.
	Mtime          int64
	Version        Ver   // The number of changes to the data of this znode.
	Cversion       Ver   // The number of changes to the children of this znode.
	Aversion       Ver   // The number of changes to the ACL of this znode.
	EphemeralOwner Sid   // The session id of the owner of this znode if the znode is an ephemeral node. If it is not an ephemeral node, it will be zero.
	DataLength     int32 // The length of the data field of this znode.
	NumChildren    int32 // The number of children of this znode.
	Pzxid          ZXid  // last modified children
}

type State int32

type SyncRequest pathRequest

type SyncResponse pathResponse

type Ver int32 // version

type WatchHandler func(ZXid, EventType)

type WatcherEvent struct {
	Type  EventType
	State State
	Path  string
}

type Watches interface {
	// Watch creates a watch request on a given path and evtype.
	Watch(rev ZXid, xid Xid, path string, evtype EventType, cb WatchHandler)

	// Wait blocks until all watches that rely on the given rev are dispatched.
	Wait(rev ZXid, path string, evtype EventType)
}

type Xid int32

type ZK interface {
	Create(xid Xid, op *CreateRequest) ZKResponse
	Delete(xid Xid, op *DeleteRequest) ZKResponse
	Exists(xid Xid, op *ExistsRequest) ZKResponse
	GetData(xid Xid, op *GetDataRequest) ZKResponse
	SetData(xid Xid, op *SetDataRequest) ZKResponse
	GetAcl(xid Xid, op *GetAclRequest) ZKResponse
	SetAcl(xid Xid, op *SetAclRequest) ZKResponse
	GetChildren(xid Xid, op *GetChildrenRequest) ZKResponse
	Sync(xid Xid, op *SyncRequest) ZKResponse
	Ping(xid Xid, op *PingRequest) ZKResponse
	GetChildren2(xid Xid, op *GetChildren2Request) ZKResponse
	// opCheck		= 13
	Multi(xid Xid, op *MultiRequest) ZKResponse
	Close(xid Xid, op *CloseRequest) ZKResponse
	SetAuth(xid Xid, op *SetAuthRequest) ZKResponse
	SetWatches(xid Xid, op *SetWatchesRequest) ZKResponse
}

type ZKFunc func(Session) (ZK, error)

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

type ZKResponse struct {
	Hdr  *ResponseHeader
	Resp interface{}

	// Err is from transmission errors, etc
	Err error
}

type ZXid int64