notifier

type Bucket struct {
	Name           string `json:"name"`
	BucketType     string `json:"bucketType"`
	UUID           string `json:"uuid"`
	StorageBackend string `json:"storageBackend"`
	NumVbucket     int    `json:"numVBuckets"`
}

type ClientTlsConfig struct {
	// UseClientCert is true when N2N encryption is all/strict and client auth type is hybrid/mandatory
	UseClientCert              bool
	ClientCertificate          *tls.Certificate
	ClientPrivateKeyPassphrase string
}

type Collection struct {
	CID string
}

type CollectionManifest struct {
	MID    string
	Scopes map[string]*Scope
}

type InterestedEvent struct {
	// Event specifies which event type to be subscribed
	Event eventType

	// Filter specifies additional filtering of events
	// For those event type where filtering is not allowed Register will return error
	Filter string
}

type Node struct {
	ThisNode             bool
	Status               string
	NodeUUID             string
	ClusterCompatibility *Version

	// Services provides the services to port mapping
	Services map[string]int

	// Contains the dns/ip address
	HostName         string
	ExternalHostName string
	NodeEncryption   bool
}

type NodeAddress struct {
	NonSSLAddress string
	SSLAddress    string
}

type Observer interface {
	// GetSubscriberObject returns a empty subscriber interface
	GetSubscriberObject() Subscriber

	// RegisterForEvents subscribes for receiving changes for interestedEvent
	// It can be called multiple times to register for different events
	// It will return Current state of the interested event
	RegisterForEvents(Subscriber, InterestedEvent) (interface{}, error)

	// DeregisterEvent removes InterestedEvent from Subscriber
	// These events won't be given in WaitForEvent once this function completes
	DeregisterEvent(Subscriber, InterestedEvent)

	// GetCurrentState returns the current state of the InterestedEvent
	// returns error if InterestEvent doesn't exist
	GetCurrentState(InterestedEvent) (interface{}, error)

	// Block till we sync with the ns_server
	WaitForConnect(ctx context.Context)
}

type Scope struct {
	SID         string
	Collections map[string]*Collection
}

type Subscriber interface {
	// WaitForEvent is a blocking call. It will be blocked till
	// some change event is called
	// nil Transition event suggest no more event coming for this subscriber
	// Its good practice to delete all the subscribed events when
	// TransitionEvent is nil
	WaitForEvent() <-chan *TransitionEvent
}

type TLSClusterConfig struct {
	SslCAFile      string
	SslCertFile    string
	SslKeyFile     string
	ClientKeyFile  string
	ClientCertFile string
}

type TlsConfig struct {
	Config             *tls.Config
	EncryptData        bool
	DisableNonSSLPorts bool
	ClientTlsConfig
}

type TransitionEvent struct {
	Event InterestedEvent

	CurrentState interface{}
	Transition   map[transition]interface{}

	// If filter is deleted then this will be set to true
	Deleted bool
}

type VBmap struct {
	// ServerList represents kv node address
	ServerList []NodeAddress

	// VbToKv is the mapping of vb to active kvnode index
	// kvNode address can be found out by ServerList
	// If VbToKv doesn't contain vb then that vb isn't
	// active on any kv node.
	VbToKv map[uint16]int
}

type Version struct {
	Minor        int
	Major        int
	MpVersion    int
	IsEnterprise bool
}