pkg/db/kvstore/consulclient.go - voltha-lib-go - Gitiles

 /*
  * Copyright 2018-present Open Networking Foundation

  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at

  * http://www.apache.org/licenses/LICENSE-2.0

  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package kvstore

 import (
 	"bytes"
 	"context"
 	"errors"
 	log "github.com/opencord/voltha-lib-go/v3/pkg/log"
 	"sync"
 	"time"
 	//log "ciena.com/coordinator/common"
 	consulapi "github.com/hashicorp/consul/api"
 )

 type channelContextMap struct {
 	ctx     context.Context
 	channel chan *Event
 	cancel  context.CancelFunc
 }

 // ConsulClient represents the consul KV store client
 type ConsulClient struct {
 	session                *consulapi.Session
 	sessionID              string
 	consul                 *consulapi.Client
 	doneCh                 *chan int
 	keyReservations        map[string]interface{}
 	watchedChannelsContext map[string][]*channelContextMap
 	writeLock              sync.Mutex
 }

 // NewConsulClient returns a new client for the Consul KV store
 func NewConsulClient(ctx context.Context, addr string, timeout time.Duration) (*ConsulClient, error) {
 	config := consulapi.DefaultConfig()
 	config.Address = addr
 	config.WaitTime = timeout
 	consul, err := consulapi.NewClient(config)
 	if err != nil {
 		logger.Error(ctx, err)
 		return nil, err
 	}

 	doneCh := make(chan int, 1)
 	wChannelsContext := make(map[string][]*channelContextMap)
 	reservations := make(map[string]interface{})
 	return &ConsulClient{consul: consul, doneCh: &doneCh, watchedChannelsContext: wChannelsContext, keyReservations: reservations}, nil
 }

 // IsConnectionUp returns whether the connection to the Consul KV store is up
 func (c *ConsulClient) IsConnectionUp(ctx context.Context) bool {
 	logger.Error(ctx, "Unimplemented function")
 	return false
 }

 // List returns an array of key-value pairs with key as a prefix.  Timeout defines how long the function will
 // wait for a response
 func (c *ConsulClient) List(ctx context.Context, key string) (map[string]*KVPair, error) {

 	deadline, _ := ctx.Deadline()
 	kv := c.consul.KV()
 	var queryOptions consulapi.QueryOptions
 	// Substract current time from deadline to get the waitTime duration
 	queryOptions.WaitTime = time.Until(deadline)

 	// For now we ignore meta data
 	kvps, _, err := kv.List(key, &queryOptions)
 	if err != nil {
 		logger.Error(ctx, err)
 		return nil, err
 	}
 	m := make(map[string]*KVPair)
 	for _, kvp := range kvps {
 		m[string(kvp.Key)] = NewKVPair(string(kvp.Key), kvp.Value, string(kvp.Session), 0, -1)
 	}
 	return m, nil
 }

 // Get returns a key-value pair for a given key. Timeout defines how long the function will
 // wait for a response
 func (c *ConsulClient) Get(ctx context.Context, key string) (*KVPair, error) {

 	deadline, _ := ctx.Deadline()
 	kv := c.consul.KV()
 	var queryOptions consulapi.QueryOptions
 	// Substract current time from deadline to get the waitTime duration
 	queryOptions.WaitTime = time.Until(deadline)

 	// For now we ignore meta data
 	kvp, _, err := kv.Get(key, &queryOptions)
 	if err != nil {
 		logger.Error(ctx, err)
 		return nil, err
 	}
 	if kvp != nil {
 		return NewKVPair(string(kvp.Key), kvp.Value, string(kvp.Session), 0, -1), nil
 	}

 	return nil, nil
 }

 // Put writes a key-value pair to the KV store.  Value can only be a string or []byte since the consul API
 // accepts only a []byte as a value for a put operation. Timeout defines how long the function will
 // wait for a response
 func (c *ConsulClient) Put(ctx context.Context, key string, value interface{}) error {

 	// Validate that we can create a byte array from the value as consul API expects a byte array
 	var val []byte
 	var er error
 	if val, er = ToByte(value); er != nil {
 		logger.Error(ctx, er)
 		return er
 	}

 	// Create a key value pair
 	kvp := consulapi.KVPair{Key: key, Value: val}
 	kv := c.consul.KV()
 	var writeOptions consulapi.WriteOptions
 	c.writeLock.Lock()
 	defer c.writeLock.Unlock()
 	_, err := kv.Put(&kvp, &writeOptions)
 	if err != nil {
 		logger.Error(ctx, err)
 		return err
 	}
 	return nil
 }

 // Delete removes a key from the KV store. Timeout defines how long the function will
 // wait for a response
 func (c *ConsulClient) Delete(ctx context.Context, key string) error {
 	kv := c.consul.KV()
 	var writeOptions consulapi.WriteOptions
 	c.writeLock.Lock()
 	defer c.writeLock.Unlock()
 	_, err := kv.Delete(key, &writeOptions)
 	if err != nil {
 		logger.Error(ctx, err)
 		return err
 	}
 	return nil
 }

 func (c *ConsulClient) deleteSession(ctx context.Context) {
 	if c.sessionID != "" {
 		logger.Debug(ctx, "cleaning-up-session")
 		session := c.consul.Session()
 		_, err := session.Destroy(c.sessionID, nil)
 		if err != nil {
 			logger.Errorw(ctx, "error-cleaning-session", log.Fields{"session": c.sessionID, "error": err})
 		}
 	}
 	c.sessionID = ""
 	c.session = nil
 }

 func (c *ConsulClient) createSession(ctx context.Context, ttl time.Duration, retries int) (*consulapi.Session, string, error) {
 	session := c.consul.Session()
 	entry := &consulapi.SessionEntry{
 		Behavior: consulapi.SessionBehaviorDelete,
 		TTL:      ttl.String(),
 	}

 	for {
 		id, meta, err := session.Create(entry, nil)
 		if err != nil {
 			logger.Errorw(ctx, "create-session-error", log.Fields{"error": err})
 			if retries == 0 {
 				return nil, "", err
 			}
 		} else if meta.RequestTime == 0 {
 			logger.Errorw(ctx, "create-session-bad-meta-data", log.Fields{"meta-data": meta})
 			if retries == 0 {
 				return nil, "", errors.New("bad-meta-data")
 			}
 		} else if id == "" {
 			logger.Error(ctx, "create-session-nil-id")
 			if retries == 0 {
 				return nil, "", errors.New("ID-nil")
 			}
 		} else {
 			return session, id, nil
 		}
 		// If retry param is -1 we will retry indefinitely
 		if retries > 0 {
 			retries--
 		}
 		logger.Debug(ctx, "retrying-session-create-after-a-second-delay")
 		time.Sleep(time.Duration(1) * time.Second)
 	}
 }

 // Helper function to verify mostly whether the content of two interface types are the same.  Focus is []byte and
 // string types
 func isEqual(val1 interface{}, val2 interface{}) bool {
 	b1, err := ToByte(val1)
 	b2, er := ToByte(val2)
 	if err == nil && er == nil {
 		return bytes.Equal(b1, b2)
 	}
 	return val1 == val2
 }

 // Reserve is invoked to acquire a key and set it to a given value. Value can only be a string or []byte since
 // the consul API accepts only a []byte.  Timeout defines how long the function will wait for a response.  TTL
 // defines how long that reservation is valid.  When TTL expires the key is unreserved by the KV store itself.
 // If the key is acquired then the value returned will be the value passed in.  If the key is already acquired
 // then the value assigned to that key will be returned.
 func (c *ConsulClient) Reserve(ctx context.Context, key string, value interface{}, ttl time.Duration) (interface{}, error) {

 	// Validate that we can create a byte array from the value as consul API expects a byte array
 	var val []byte
 	var er error
 	if val, er = ToByte(value); er != nil {
 		logger.Error(ctx, er)
 		return nil, er
 	}

 	// Cleanup any existing session and recreate new ones.  A key is reserved against a session
 	if c.sessionID != "" {
 		c.deleteSession(ctx)
 	}

 	// Clear session if reservation is not successful
 	reservationSuccessful := false
 	defer func() {
 		if !reservationSuccessful {
 			logger.Debug(ctx, "deleting-session")
 			c.deleteSession(ctx)
 		}
 	}()

 	session, sessionID, err := c.createSession(ctx, ttl, -1)
 	if err != nil {
 		logger.Errorw(ctx, "no-session-created", log.Fields{"error": err})
 		return "", errors.New("no-session-created")
 	}
 	logger.Debugw(ctx, "session-created", log.Fields{"session-id": sessionID})
 	c.sessionID = sessionID
 	c.session = session

 	// Try to grap the Key using the session
 	kv := c.consul.KV()
 	kvp := consulapi.KVPair{Key: key, Value: val, Session: c.sessionID}
 	result, _, err := kv.Acquire(&kvp, nil)
 	if err != nil {
 		logger.Errorw(ctx, "error-acquiring-keys", log.Fields{"error": err})
 		return nil, err
 	}

 	logger.Debugw(ctx, "key-acquired", log.Fields{"key": key, "status": result})

 	// Irrespective whether we were successful in acquiring the key, let's read it back and see if it's us.
 	m, err := c.Get(ctx, key)
 	if err != nil {
 		return nil, err
 	}
 	if m != nil {
 		logger.Debugw(ctx, "response-received", log.Fields{"key": m.Key, "m.value": string(m.Value.([]byte)), "value": value})
 		if m.Key == key && isEqual(m.Value, value) {
 			// My reservation is successful - register it.  For now, support is only for 1 reservation per key
 			// per session.
 			reservationSuccessful = true
 			c.writeLock.Lock()
 			c.keyReservations[key] = m.Value
 			c.writeLock.Unlock()
 			return m.Value, nil
 		}
 		// My reservation has failed.  Return the owner of that key
 		return m.Value, nil
 	}
 	return nil, nil
 }

 // ReleaseAllReservations releases all key reservations previously made (using Reserve API)
 func (c *ConsulClient) ReleaseAllReservations(ctx context.Context) error {
 	kv := c.consul.KV()
 	var kvp consulapi.KVPair
 	var result bool
 	var err error

 	c.writeLock.Lock()
 	defer c.writeLock.Unlock()

 	for key, value := range c.keyReservations {
 		kvp = consulapi.KVPair{Key: key, Value: value.([]byte), Session: c.sessionID}
 		result, _, err = kv.Release(&kvp, nil)
 		if err != nil {
 			logger.Errorw(ctx, "cannot-release-reservation", log.Fields{"key": key, "error": err})
 			return err
 		}
 		if !result {
 			logger.Errorw(ctx, "cannot-release-reservation", log.Fields{"key": key})
 		}
 		delete(c.keyReservations, key)
 	}
 	return nil
 }

 // ReleaseReservation releases reservation for a specific key.
 func (c *ConsulClient) ReleaseReservation(ctx context.Context, key string) error {
 	var ok bool
 	var reservedValue interface{}
 	c.writeLock.Lock()
 	defer c.writeLock.Unlock()
 	if reservedValue, ok = c.keyReservations[key]; !ok {
 		return errors.New("key-not-reserved:" + key)
 	}
 	// Release the reservation
 	kv := c.consul.KV()
 	kvp := consulapi.KVPair{Key: key, Value: reservedValue.([]byte), Session: c.sessionID}

 	result, _, er := kv.Release(&kvp, nil)
 	if er != nil {
 		return er
 	}
 	// Remove that key entry on success
 	if result {
 		delete(c.keyReservations, key)
 		return nil
 	}
 	return errors.New("key-cannot-be-unreserved")
 }

 // RenewReservation renews a reservation.  A reservation will go stale after the specified TTL (Time To Live)
 // period specified when reserving the key
 func (c *ConsulClient) RenewReservation(ctx context.Context, key string) error {
 	// In the case of Consul, renew reservation of a reserve key only require renewing the client session.

 	c.writeLock.Lock()
 	defer c.writeLock.Unlock()

 	// Verify the key was reserved
 	if _, ok := c.keyReservations[key]; !ok {
 		return errors.New("key-not-reserved")
 	}

 	if c.session == nil {
 		return errors.New("no-session-exist")
 	}

 	var writeOptions consulapi.WriteOptions
 	if _, _, err := c.session.Renew(c.sessionID, &writeOptions); err != nil {
 		return err
 	}
 	return nil
 }

 // Watch provides the watch capability on a given key.  It returns a channel onto which the callee needs to
 // listen to receive Events.
 func (c *ConsulClient) Watch(ctx context.Context, key string, withPrefix bool) chan *Event {

 	// Create a new channel
 	ch := make(chan *Event, maxClientChannelBufferSize)

 	// Create a context to track this request
 	watchContext, cFunc := context.WithCancel(context.Background())

 	// Save the channel and context reference for later
 	c.writeLock.Lock()
 	defer c.writeLock.Unlock()
 	ccm := channelContextMap{channel: ch, ctx: watchContext, cancel: cFunc}
 	c.watchedChannelsContext[key] = append(c.watchedChannelsContext[key], &ccm)

 	// Launch a go routine to listen for updates
 	go c.listenForKeyChange(watchContext, key, ch)

 	return ch
 }

 // CloseWatch closes a specific watch. Both the key and the channel are required when closing a watch as there
 // may be multiple listeners on the same key.  The previously created channel serves as a key
 func (c *ConsulClient) CloseWatch(ctx context.Context, key string, ch chan *Event) {
 	// First close the context
 	var ok bool
 	var watchedChannelsContexts []*channelContextMap
 	c.writeLock.Lock()
 	defer c.writeLock.Unlock()
 	if watchedChannelsContexts, ok = c.watchedChannelsContext[key]; !ok {
 		logger.Errorw(ctx, "key-has-no-watched-context-or-channel", log.Fields{"key": key})
 		return
 	}
 	// Look for the channels
 	var pos = -1
 	for i, chCtxMap := range watchedChannelsContexts {
 		if chCtxMap.channel == ch {
 			logger.Debug(ctx, "channel-found")
 			chCtxMap.cancel()
 			//close the channel
 			close(ch)
 			pos = i
 			break
 		}
 	}
 	// Remove that entry if present
 	if pos >= 0 {
 		c.watchedChannelsContext[key] = append(c.watchedChannelsContext[key][:pos], c.watchedChannelsContext[key][pos+1:]...)
 	}
 	logger.Debugw(ctx, "watched-channel-exiting", log.Fields{"key": key, "channel": c.watchedChannelsContext[key]})
 }

 func (c *ConsulClient) isKVEqual(kv1 *consulapi.KVPair, kv2 *consulapi.KVPair) bool {
 	if (kv1 == nil) && (kv2 == nil) {
 		return true
 	} else if (kv1 == nil) || (kv2 == nil) {
 		return false
 	}
 	// Both the KV should be non-null here
 	if kv1.Key != kv2.Key ||
 		!bytes.Equal(kv1.Value, kv2.Value) ||
 		kv1.Session != kv2.Session ||
 		kv1.LockIndex != kv2.LockIndex ||
 		kv1.ModifyIndex != kv2.ModifyIndex {
 		return false
 	}
 	return true
 }

 func (c *ConsulClient) listenForKeyChange(ctx context.Context, key string, ch chan *Event) {
 	logger.Debugw(ctx, "start-watching-channel", log.Fields{"key": key, "channel": ch})

 	defer c.CloseWatch(ctx, key, ch)
 	kv := c.consul.KV()
 	var queryOptions consulapi.QueryOptions
 	queryOptions.WaitTime = defaultKVGetTimeout

 	// Get the existing value, if any
 	previousKVPair, meta, err := kv.Get(key, &queryOptions)
 	if err != nil {
 		logger.Debug(ctx, err)
 	}
 	lastIndex := meta.LastIndex

 	// Wait for change.  Push any change onto the channel and keep waiting for new update
 	//var waitOptions consulapi.QueryOptions
 	var pair *consulapi.KVPair
 	//watchContext, _ := context.WithCancel(context.Background())
 	waitOptions := queryOptions.WithContext(ctx)
 	for {
 		//waitOptions = consulapi.QueryOptions{WaitIndex: lastIndex}
 		waitOptions.WaitIndex = lastIndex
 		pair, meta, err = kv.Get(key, waitOptions)
 		select {
 		case <-ctx.Done():
 			logger.Debug(ctx, "done-event-received-exiting")
 			return
 		default:
 			if err != nil {
 				logger.Warnw(ctx, "error-from-watch", log.Fields{"error": err})
 				ch <- NewEvent(CONNECTIONDOWN, key, []byte(""), -1)
 			} else {
 				logger.Debugw(ctx, "index-state", log.Fields{"lastindex": lastIndex, "newindex": meta.LastIndex, "key": key})
 			}
 		}
 		if err != nil {
 			logger.Debug(ctx, err)
 			// On error, block for 10 milliseconds to prevent endless loop
 			time.Sleep(10 * time.Millisecond)
 		} else if meta.LastIndex <= lastIndex {
 			logger.Info(ctx, "no-index-change-or-negative")
 		} else {
 			logger.Debugw(ctx, "update-received", log.Fields{"pair": pair})
 			if pair == nil {
 				ch <- NewEvent(DELETE, key, []byte(""), -1)
 			} else if !c.isKVEqual(pair, previousKVPair) {
 				// Push the change onto the channel if the data has changed
 				// For now just assume it's a PUT change
 				logger.Debugw(ctx, "pair-details", log.Fields{"session": pair.Session, "key": pair.Key, "value": pair.Value})
 				ch <- NewEvent(PUT, pair.Key, pair.Value, -1)
 			}
 			previousKVPair = pair
 			lastIndex = meta.LastIndex
 		}
 	}
 }

 // Close closes the KV store client
 func (c *ConsulClient) Close(ctx context.Context) {
 	var writeOptions consulapi.WriteOptions
 	// Inform any goroutine it's time to say goodbye.
 	c.writeLock.Lock()
 	defer c.writeLock.Unlock()
 	if c.doneCh != nil {
 		close(*c.doneCh)
 	}

 	// Clear the sessionID
 	if _, err := c.consul.Session().Destroy(c.sessionID, &writeOptions); err != nil {
 		logger.Errorw(ctx, "error-closing-client", log.Fields{"error": err})
 	}
 }

 func (c *ConsulClient) AcquireLock(ctx context.Context, lockName string, timeout time.Duration) error {
 	return nil
 }

 func (c *ConsulClient) ReleaseLock(lockName string) error {
 	return nil
 }
	/*
	* Copyright 2018-present Open Networking Foundation

	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at

	* http://www.apache.org/licenses/LICENSE-2.0

	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package kvstore

	import (
	"bytes"
	"context"
	"errors"
	log "github.com/opencord/voltha-lib-go/v3/pkg/log"
	"sync"
	"time"
	//log "ciena.com/coordinator/common"
	consulapi "github.com/hashicorp/consul/api"
	)

	type channelContextMap struct {
	ctx context.Context
	channel chan *Event
	cancel context.CancelFunc
	}

	// ConsulClient represents the consul KV store client
	type ConsulClient struct {
	session *consulapi.Session
	sessionID string
	consul *consulapi.Client
	doneCh *chan int
	keyReservations map[string]interface{}
	watchedChannelsContext map[string][]*channelContextMap
	writeLock sync.Mutex
	}

	// NewConsulClient returns a new client for the Consul KV store
	func NewConsulClient(ctx context.Context, addr string, timeout time.Duration) (*ConsulClient, error) {
	config := consulapi.DefaultConfig()
	config.Address = addr
	config.WaitTime = timeout
	consul, err := consulapi.NewClient(config)
	if err != nil {
	logger.Error(ctx, err)
	return nil, err
	}

	doneCh := make(chan int, 1)
	wChannelsContext := make(map[string][]*channelContextMap)
	reservations := make(map[string]interface{})
	return &ConsulClient{consul: consul, doneCh: &doneCh, watchedChannelsContext: wChannelsContext, keyReservations: reservations}, nil
	}

	// IsConnectionUp returns whether the connection to the Consul KV store is up
	func (c *ConsulClient) IsConnectionUp(ctx context.Context) bool {
	logger.Error(ctx, "Unimplemented function")
	return false
	}

	// List returns an array of key-value pairs with key as a prefix. Timeout defines how long the function will
	// wait for a response
	func (c ConsulClient) List(ctx context.Context, key string) (map[string]KVPair, error) {

	deadline, _ := ctx.Deadline()
	kv := c.consul.KV()
	var queryOptions consulapi.QueryOptions
	// Substract current time from deadline to get the waitTime duration
	queryOptions.WaitTime = time.Until(deadline)

	// For now we ignore meta data
	kvps, _, err := kv.List(key, &queryOptions)
	if err != nil {
	logger.Error(ctx, err)
	return nil, err
	}
	m := make(map[string]*KVPair)
	for _, kvp := range kvps {
	m[string(kvp.Key)] = NewKVPair(string(kvp.Key), kvp.Value, string(kvp.Session), 0, -1)
	}
	return m, nil
	}

	// Get returns a key-value pair for a given key. Timeout defines how long the function will
	// wait for a response
	func (c ConsulClient) Get(ctx context.Context, key string) (KVPair, error) {

	deadline, _ := ctx.Deadline()
	kv := c.consul.KV()
	var queryOptions consulapi.QueryOptions
	// Substract current time from deadline to get the waitTime duration
	queryOptions.WaitTime = time.Until(deadline)

	// For now we ignore meta data
	kvp, _, err := kv.Get(key, &queryOptions)
	if err != nil {
	logger.Error(ctx, err)
	return nil, err
	}
	if kvp != nil {
	return NewKVPair(string(kvp.Key), kvp.Value, string(kvp.Session), 0, -1), nil
	}

	return nil, nil
	}

	// Put writes a key-value pair to the KV store. Value can only be a string or []byte since the consul API
	// accepts only a []byte as a value for a put operation. Timeout defines how long the function will
	// wait for a response
	func (c *ConsulClient) Put(ctx context.Context, key string, value interface{}) error {

	// Validate that we can create a byte array from the value as consul API expects a byte array
	var val []byte
	var er error
	if val, er = ToByte(value); er != nil {
	logger.Error(ctx, er)
	return er
	}

	// Create a key value pair
	kvp := consulapi.KVPair{Key: key, Value: val}
	kv := c.consul.KV()
	var writeOptions consulapi.WriteOptions
	c.writeLock.Lock()
	defer c.writeLock.Unlock()
	_, err := kv.Put(&kvp, &writeOptions)
	if err != nil {
	logger.Error(ctx, err)
	return err
	}
	return nil
	}

	// Delete removes a key from the KV store. Timeout defines how long the function will
	// wait for a response
	func (c *ConsulClient) Delete(ctx context.Context, key string) error {
	kv := c.consul.KV()
	var writeOptions consulapi.WriteOptions
	c.writeLock.Lock()
	defer c.writeLock.Unlock()
	_, err := kv.Delete(key, &writeOptions)
	if err != nil {
	logger.Error(ctx, err)
	return err
	}
	return nil
	}

	func (c *ConsulClient) deleteSession(ctx context.Context) {
	if c.sessionID != "" {
	logger.Debug(ctx, "cleaning-up-session")
	session := c.consul.Session()
	_, err := session.Destroy(c.sessionID, nil)
	if err != nil {
	logger.Errorw(ctx, "error-cleaning-session", log.Fields{"session": c.sessionID, "error": err})
	}
	}
	c.sessionID = ""
	c.session = nil
	}

	func (c ConsulClient) createSession(ctx context.Context, ttl time.Duration, retries int) (consulapi.Session, string, error) {
	session := c.consul.Session()
	entry := &consulapi.SessionEntry{
	Behavior: consulapi.SessionBehaviorDelete,
	TTL: ttl.String(),
	}

	for {
	id, meta, err := session.Create(entry, nil)
	if err != nil {
	logger.Errorw(ctx, "create-session-error", log.Fields{"error": err})
	if retries == 0 {
	return nil, "", err
	}
	} else if meta.RequestTime == 0 {
	logger.Errorw(ctx, "create-session-bad-meta-data", log.Fields{"meta-data": meta})
	if retries == 0 {
	return nil, "", errors.New("bad-meta-data")
	}
	} else if id == "" {
	logger.Error(ctx, "create-session-nil-id")
	if retries == 0 {
	return nil, "", errors.New("ID-nil")
	}
	} else {
	return session, id, nil
	}
	// If retry param is -1 we will retry indefinitely
	if retries > 0 {
	retries--
	}
	logger.Debug(ctx, "retrying-session-create-after-a-second-delay")
	time.Sleep(time.Duration(1) * time.Second)
	}
	}

	// Helper function to verify mostly whether the content of two interface types are the same. Focus is []byte and
	// string types
	func isEqual(val1 interface{}, val2 interface{}) bool {
	b1, err := ToByte(val1)
	b2, er := ToByte(val2)
	if err == nil && er == nil {
	return bytes.Equal(b1, b2)
	}
	return val1 == val2
	}

	// Reserve is invoked to acquire a key and set it to a given value. Value can only be a string or []byte since
	// the consul API accepts only a []byte. Timeout defines how long the function will wait for a response. TTL
	// defines how long that reservation is valid. When TTL expires the key is unreserved by the KV store itself.
	// If the key is acquired then the value returned will be the value passed in. If the key is already acquired
	// then the value assigned to that key will be returned.
	func (c *ConsulClient) Reserve(ctx context.Context, key string, value interface{}, ttl time.Duration) (interface{}, error) {

	// Validate that we can create a byte array from the value as consul API expects a byte array
	var val []byte
	var er error
	if val, er = ToByte(value); er != nil {
	logger.Error(ctx, er)
	return nil, er
	}

	// Cleanup any existing session and recreate new ones. A key is reserved against a session
	if c.sessionID != "" {
	c.deleteSession(ctx)
	}

	// Clear session if reservation is not successful
	reservationSuccessful := false
	defer func() {
	if !reservationSuccessful {
	logger.Debug(ctx, "deleting-session")
	c.deleteSession(ctx)
	}
	}()

	session, sessionID, err := c.createSession(ctx, ttl, -1)
	if err != nil {
	logger.Errorw(ctx, "no-session-created", log.Fields{"error": err})
	return "", errors.New("no-session-created")
	}
	logger.Debugw(ctx, "session-created", log.Fields{"session-id": sessionID})
	c.sessionID = sessionID
	c.session = session

	// Try to grap the Key using the session
	kv := c.consul.KV()
	kvp := consulapi.KVPair{Key: key, Value: val, Session: c.sessionID}
	result, _, err := kv.Acquire(&kvp, nil)
	if err != nil {
	logger.Errorw(ctx, "error-acquiring-keys", log.Fields{"error": err})
	return nil, err
	}

	logger.Debugw(ctx, "key-acquired", log.Fields{"key": key, "status": result})

	// Irrespective whether we were successful in acquiring the key, let's read it back and see if it's us.
	m, err := c.Get(ctx, key)
	if err != nil {
	return nil, err
	}
	if m != nil {
	logger.Debugw(ctx, "response-received", log.Fields{"key": m.Key, "m.value": string(m.Value.([]byte)), "value": value})
	if m.Key == key && isEqual(m.Value, value) {
	// My reservation is successful - register it. For now, support is only for 1 reservation per key
	// per session.
	reservationSuccessful = true
	c.writeLock.Lock()
	c.keyReservations[key] = m.Value
	c.writeLock.Unlock()
	return m.Value, nil
	}
	// My reservation has failed. Return the owner of that key
	return m.Value, nil
	}
	return nil, nil
	}

	// ReleaseAllReservations releases all key reservations previously made (using Reserve API)
	func (c *ConsulClient) ReleaseAllReservations(ctx context.Context) error {
	kv := c.consul.KV()
	var kvp consulapi.KVPair
	var result bool
	var err error

	c.writeLock.Lock()
	defer c.writeLock.Unlock()

	for key, value := range c.keyReservations {
	kvp = consulapi.KVPair{Key: key, Value: value.([]byte), Session: c.sessionID}
	result, _, err = kv.Release(&kvp, nil)
	if err != nil {
	logger.Errorw(ctx, "cannot-release-reservation", log.Fields{"key": key, "error": err})
	return err
	}
	if !result {
	logger.Errorw(ctx, "cannot-release-reservation", log.Fields{"key": key})
	}
	delete(c.keyReservations, key)
	}
	return nil
	}

	// ReleaseReservation releases reservation for a specific key.
	func (c *ConsulClient) ReleaseReservation(ctx context.Context, key string) error {
	var ok bool
	var reservedValue interface{}
	c.writeLock.Lock()
	defer c.writeLock.Unlock()
	if reservedValue, ok = c.keyReservations[key]; !ok {
	return errors.New("key-not-reserved:" + key)
	}
	// Release the reservation
	kv := c.consul.KV()
	kvp := consulapi.KVPair{Key: key, Value: reservedValue.([]byte), Session: c.sessionID}

	result, _, er := kv.Release(&kvp, nil)
	if er != nil {
	return er
	}
	// Remove that key entry on success
	if result {
	delete(c.keyReservations, key)
	return nil
	}
	return errors.New("key-cannot-be-unreserved")
	}

	// RenewReservation renews a reservation. A reservation will go stale after the specified TTL (Time To Live)
	// period specified when reserving the key
	func (c *ConsulClient) RenewReservation(ctx context.Context, key string) error {
	// In the case of Consul, renew reservation of a reserve key only require renewing the client session.

	c.writeLock.Lock()
	defer c.writeLock.Unlock()

	// Verify the key was reserved
	if _, ok := c.keyReservations[key]; !ok {
	return errors.New("key-not-reserved")
	}

	if c.session == nil {
	return errors.New("no-session-exist")
	}

	var writeOptions consulapi.WriteOptions
	if _, _, err := c.session.Renew(c.sessionID, &writeOptions); err != nil {
	return err
	}
	return nil
	}

	// Watch provides the watch capability on a given key. It returns a channel onto which the callee needs to
	// listen to receive Events.
	func (c ConsulClient) Watch(ctx context.Context, key string, withPrefix bool) chan Event {

	// Create a new channel
	ch := make(chan *Event, maxClientChannelBufferSize)

	// Create a context to track this request
	watchContext, cFunc := context.WithCancel(context.Background())

	// Save the channel and context reference for later
	c.writeLock.Lock()
	defer c.writeLock.Unlock()
	ccm := channelContextMap{channel: ch, ctx: watchContext, cancel: cFunc}
	c.watchedChannelsContext[key] = append(c.watchedChannelsContext[key], &ccm)

	// Launch a go routine to listen for updates
	go c.listenForKeyChange(watchContext, key, ch)

	return ch
	}

	// CloseWatch closes a specific watch. Both the key and the channel are required when closing a watch as there
	// may be multiple listeners on the same key. The previously created channel serves as a key
	func (c ConsulClient) CloseWatch(ctx context.Context, key string, ch chan Event) {
	// First close the context
	var ok bool
	var watchedChannelsContexts []*channelContextMap
	c.writeLock.Lock()
	defer c.writeLock.Unlock()
	if watchedChannelsContexts, ok = c.watchedChannelsContext[key]; !ok {
	logger.Errorw(ctx, "key-has-no-watched-context-or-channel", log.Fields{"key": key})
	return
	}
	// Look for the channels
	var pos = -1
	for i, chCtxMap := range watchedChannelsContexts {
	if chCtxMap.channel == ch {
	logger.Debug(ctx, "channel-found")
	chCtxMap.cancel()
	//close the channel
	close(ch)
	pos = i
	break
	}
	}
	// Remove that entry if present
	if pos >= 0 {
	c.watchedChannelsContext[key] = append(c.watchedChannelsContext[key][:pos], c.watchedChannelsContext[key][pos+1:]...)
	}
	logger.Debugw(ctx, "watched-channel-exiting", log.Fields{"key": key, "channel": c.watchedChannelsContext[key]})
	}

	func (c ConsulClient) isKVEqual(kv1 consulapi.KVPair, kv2 *consulapi.KVPair) bool {
	if (kv1 == nil) && (kv2 == nil) {
	return true
	} else if (kv1 == nil) \|\| (kv2 == nil) {
	return false
	}
	// Both the KV should be non-null here
	if kv1.Key != kv2.Key \|\|
	!bytes.Equal(kv1.Value, kv2.Value) \|\|
	kv1.Session != kv2.Session \|\|
	kv1.LockIndex != kv2.LockIndex \|\|
	kv1.ModifyIndex != kv2.ModifyIndex {
	return false
	}
	return true
	}

	func (c ConsulClient) listenForKeyChange(ctx context.Context, key string, ch chan Event) {
	logger.Debugw(ctx, "start-watching-channel", log.Fields{"key": key, "channel": ch})

	defer c.CloseWatch(ctx, key, ch)
	kv := c.consul.KV()
	var queryOptions consulapi.QueryOptions
	queryOptions.WaitTime = defaultKVGetTimeout

	// Get the existing value, if any
	previousKVPair, meta, err := kv.Get(key, &queryOptions)
	if err != nil {
	logger.Debug(ctx, err)
	}
	lastIndex := meta.LastIndex

	// Wait for change. Push any change onto the channel and keep waiting for new update
	//var waitOptions consulapi.QueryOptions
	var pair *consulapi.KVPair
	//watchContext, _ := context.WithCancel(context.Background())
	waitOptions := queryOptions.WithContext(ctx)
	for {
	//waitOptions = consulapi.QueryOptions{WaitIndex: lastIndex}
	waitOptions.WaitIndex = lastIndex
	pair, meta, err = kv.Get(key, waitOptions)
	select {
	case <-ctx.Done():
	logger.Debug(ctx, "done-event-received-exiting")
	return
	default:
	if err != nil {
	logger.Warnw(ctx, "error-from-watch", log.Fields{"error": err})
	ch <- NewEvent(CONNECTIONDOWN, key, []byte(""), -1)
	} else {
	logger.Debugw(ctx, "index-state", log.Fields{"lastindex": lastIndex, "newindex": meta.LastIndex, "key": key})
	}
	}
	if err != nil {
	logger.Debug(ctx, err)
	// On error, block for 10 milliseconds to prevent endless loop
	time.Sleep(10 * time.Millisecond)
	} else if meta.LastIndex <= lastIndex {
	logger.Info(ctx, "no-index-change-or-negative")
	} else {
	logger.Debugw(ctx, "update-received", log.Fields{"pair": pair})
	if pair == nil {
	ch <- NewEvent(DELETE, key, []byte(""), -1)
	} else if !c.isKVEqual(pair, previousKVPair) {
	// Push the change onto the channel if the data has changed
	// For now just assume it's a PUT change
	logger.Debugw(ctx, "pair-details", log.Fields{"session": pair.Session, "key": pair.Key, "value": pair.Value})
	ch <- NewEvent(PUT, pair.Key, pair.Value, -1)
	}
	previousKVPair = pair
	lastIndex = meta.LastIndex
	}
	}
	}

	// Close closes the KV store client
	func (c *ConsulClient) Close(ctx context.Context) {
	var writeOptions consulapi.WriteOptions
	// Inform any goroutine it's time to say goodbye.
	c.writeLock.Lock()
	defer c.writeLock.Unlock()
	if c.doneCh != nil {
	close(*c.doneCh)
	}

	// Clear the sessionID
	if _, err := c.consul.Session().Destroy(c.sessionID, &writeOptions); err != nil {
	logger.Errorw(ctx, "error-closing-client", log.Fields{"error": err})
	}
	}

	func (c *ConsulClient) AcquireLock(ctx context.Context, lockName string, timeout time.Duration) error {
	return nil
	}

	func (c *ConsulClient) ReleaseLock(lockName string) error {
	return nil
	}