diff --git a/db/model/proxy.go b/db/model/proxy.go
index a7eedda..f4c8bbc 100644
--- a/db/model/proxy.go
+++ b/db/model/proxy.go
@@ -21,12 +21,13 @@
 	"crypto/md5"
 	"errors"
 	"fmt"
-	"github.com/google/uuid"
-	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"reflect"
 	"runtime"
 	"strings"
 	"sync"
+
+	"github.com/google/uuid"
+	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 )
 
 // OperationContext holds details on the information used during an operation
@@ -85,8 +86,8 @@
 	return p
 }
 
-// GetRoot returns the root attribute of the proxy
-func (p *Proxy) GetRoot() *root {
+// getRoot returns the root attribute of the proxy
+func (p *Proxy) getRoot() *root {
 	return p.Root
 }
 
@@ -146,19 +147,19 @@
 	delete(p.Callbacks[callbackType], funcHash)
 }
 
-// CallbackType is an enumerated value to express when a callback should be executed
+// ProxyOperation callbackType is an enumerated value to express when a callback should be executed
 type ProxyOperation uint8
 
 // Enumerated list of callback types
 const (
-	PROXY_NONE ProxyOperation = iota
-	PROXY_GET
-	PROXY_LIST
-	PROXY_ADD
-	PROXY_UPDATE
-	PROXY_REMOVE
-	PROXY_CREATE
-	PROXY_WATCH
+	ProxyNone ProxyOperation = iota
+	ProxyGet
+	ProxyList
+	ProxyAdd
+	ProxyUpdate
+	ProxyRemove
+	ProxyCreate
+	ProxyWatch
 )
 
 var proxyOperationTypes = []string{
@@ -176,12 +177,14 @@
 	return proxyOperationTypes[t]
 }
 
+// GetOperation -
 func (p *Proxy) GetOperation() ProxyOperation {
 	p.mutex.RLock()
 	defer p.mutex.RUnlock()
 	return p.operation
 }
 
+// SetOperation -
 func (p *Proxy) SetOperation(operation ProxyOperation) {
 	p.mutex.Lock()
 	defer p.mutex.Unlock()
@@ -201,7 +204,6 @@
 		case 2:
 			controlled = false
 			pathLock = ""
-			break
 		case 3:
 			fallthrough
 		default:
@@ -224,8 +226,8 @@
 
 	pathLock, controlled := p.parseForControlledPath(effectivePath)
 
-	p.SetOperation(PROXY_LIST)
-	defer p.SetOperation(PROXY_NONE)
+	p.SetOperation(ProxyList)
+	defer p.SetOperation(ProxyNone)
 
 	log.Debugw("proxy-list", log.Fields{
 		"path":       path,
@@ -234,7 +236,7 @@
 		"controlled": controlled,
 		"operation":  p.GetOperation(),
 	})
-	return p.GetRoot().List(ctx, path, "", depth, deep, txid)
+	return p.getRoot().List(ctx, path, "", depth, deep, txid)
 }
 
 // Get will retrieve information from the data model at the specified path location
@@ -248,8 +250,8 @@
 
 	pathLock, controlled := p.parseForControlledPath(effectivePath)
 
-	p.SetOperation(PROXY_GET)
-	defer p.SetOperation(PROXY_NONE)
+	p.SetOperation(ProxyGet)
+	defer p.SetOperation(ProxyNone)
 
 	log.Debugw("proxy-get", log.Fields{
 		"path":       path,
@@ -259,7 +261,7 @@
 		"operation":  p.GetOperation(),
 	})
 
-	return p.GetRoot().Get(ctx, path, "", depth, deep, txid)
+	return p.getRoot().Get(ctx, path, "", depth, deep, txid)
 }
 
 // Update will modify information in the data model at the specified location with the provided data
@@ -280,8 +282,8 @@
 
 	pathLock, controlled := p.parseForControlledPath(effectivePath)
 
-	p.SetOperation(PROXY_UPDATE)
-	defer p.SetOperation(PROXY_NONE)
+	p.SetOperation(ProxyUpdate)
+	defer p.SetOperation(ProxyNone)
 
 	log.Debugw("proxy-update", log.Fields{
 		"path":       path,
@@ -292,15 +294,20 @@
 		"operation":  p.GetOperation(),
 	})
 
-	if p.GetRoot().KvStore != nil {
-		if _, err := p.GetRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
+	if p.getRoot().KvStore != nil {
+		if _, err := p.getRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
 			log.Errorw("unable-to-acquire-key-from-kvstore", log.Fields{"error": err})
 			return nil, err
 		}
-		defer p.GetRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+		defer func() {
+			err := p.getRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+			if err != nil {
+				log.Errorw("Unable to release reservation for key", log.Fields{"error": err})
+			}
+		}()
 	}
 
-	result := p.GetRoot().Update(ctx, fullPath, data, strict, txid, nil)
+	result := p.getRoot().Update(ctx, fullPath, data, strict, txid, nil)
 
 	if result != nil {
 		return result.GetData(), nil
@@ -329,8 +336,8 @@
 
 	pathLock, controlled := p.parseForControlledPath(effectivePath)
 
-	p.SetOperation(PROXY_ADD)
-	defer p.SetOperation(PROXY_NONE)
+	p.SetOperation(ProxyAdd)
+	defer p.SetOperation(ProxyNone)
 
 	log.Debugw("proxy-add-with-id", log.Fields{
 		"path":       path,
@@ -341,15 +348,20 @@
 		"operation":  p.GetOperation(),
 	})
 
-	if p.GetRoot().KvStore != nil {
-		if _, err := p.GetRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
+	if p.getRoot().KvStore != nil {
+		if _, err := p.getRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
 			log.Errorw("unable-to-acquire-key-from-kvstore", log.Fields{"error": err})
 			return nil, err
 		}
-		defer p.GetRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+		defer func() {
+			err := p.getRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+			if err != nil {
+				log.Errorw("Unable to release reservation for key", log.Fields{"error": err})
+			}
+		}()
 	}
 
-	result := p.GetRoot().Add(ctx, fullPath, data, txid, nil)
+	result := p.getRoot().Add(ctx, fullPath, data, txid, nil)
 
 	if result != nil {
 		return result.GetData(), nil
@@ -376,8 +388,8 @@
 
 	pathLock, controlled := p.parseForControlledPath(effectivePath)
 
-	p.SetOperation(PROXY_ADD)
-	defer p.SetOperation(PROXY_NONE)
+	p.SetOperation(ProxyAdd)
+	defer p.SetOperation(ProxyNone)
 
 	log.Debugw("proxy-add", log.Fields{
 		"path":       path,
@@ -388,15 +400,20 @@
 		"operation":  p.GetOperation(),
 	})
 
-	if p.GetRoot().KvStore != nil {
-		if _, err := p.GetRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
+	if p.getRoot().KvStore != nil {
+		if _, err := p.getRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
 			log.Errorw("unable-to-acquire-key-from-kvstore", log.Fields{"error": err})
 			return nil, err
 		}
-		defer p.GetRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+		defer func() {
+			err := p.getRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+			if err != nil {
+				log.Errorw("Unable to release reservation for key", log.Fields{"error": err})
+			}
+		}()
 	}
 
-	result := p.GetRoot().Add(ctx, fullPath, data, txid, nil)
+	result := p.getRoot().Add(ctx, fullPath, data, txid, nil)
 
 	if result != nil {
 		return result.GetData(), nil
@@ -423,8 +440,8 @@
 
 	pathLock, controlled := p.parseForControlledPath(effectivePath)
 
-	p.SetOperation(PROXY_REMOVE)
-	defer p.SetOperation(PROXY_NONE)
+	p.SetOperation(ProxyRemove)
+	defer p.SetOperation(ProxyNone)
 
 	log.Debugw("proxy-remove", log.Fields{
 		"path":       path,
@@ -435,15 +452,20 @@
 		"operation":  p.GetOperation(),
 	})
 
-	if p.GetRoot().KvStore != nil {
-		if _, err := p.GetRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
+	if p.getRoot().KvStore != nil {
+		if _, err := p.getRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
 			log.Errorw("unable-to-acquire-key-from-kvstore", log.Fields{"error": err})
 			return nil, err
 		}
-		defer p.GetRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+		defer func() {
+			err := p.getRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+			if err != nil {
+				log.Errorw("Unable to release reservation for key", log.Fields{"error": err})
+			}
+		}()
 	}
 
-	result := p.GetRoot().Remove(ctx, fullPath, txid, nil)
+	result := p.getRoot().Remove(ctx, fullPath, txid, nil)
 
 	if result != nil {
 		return result.GetData(), nil
@@ -471,8 +493,8 @@
 
 	pathLock, controlled := p.parseForControlledPath(effectivePath)
 
-	p.SetOperation(PROXY_CREATE)
-	defer p.SetOperation(PROXY_NONE)
+	p.SetOperation(ProxyCreate)
+	defer p.SetOperation(ProxyNone)
 
 	log.Debugw("proxy-create", log.Fields{
 		"path":       path,
@@ -483,30 +505,35 @@
 		"operation":  p.GetOperation(),
 	})
 
-	if p.GetRoot().KvStore != nil {
-		if _, err := p.GetRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
+	if p.getRoot().KvStore != nil {
+		if _, err := p.getRoot().KvStore.Client.Reserve(pathLock+"_", uuid.New().String(), ReservationTTL); err != nil {
 			log.Errorw("unable-to-acquire-key-from-kvstore", log.Fields{"error": err})
 			return nil, err
 		}
-		defer p.GetRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+		defer func() {
+			err := p.getRoot().KvStore.Client.ReleaseReservation(pathLock + "_")
+			if err != nil {
+				log.Errorw("Unable to release reservation for key", log.Fields{"error": err})
+			}
+		}()
 	}
-	return p.GetRoot().CreateProxy(ctx, fullPath, exclusive)
+	return p.getRoot().CreateProxy(ctx, fullPath, exclusive)
 }
 
 // OpenTransaction creates a new transaction branch to isolate operations made to the data model
 func (p *Proxy) OpenTransaction() *Transaction {
-	txid := p.GetRoot().MakeTxBranch()
+	txid := p.getRoot().MakeTxBranch()
 	return NewTransaction(p, txid)
 }
 
 // commitTransaction will apply and merge modifications made in the transaction branch to the data model
 func (p *Proxy) commitTransaction(txid string) {
-	p.GetRoot().FoldTxBranch(txid)
+	p.getRoot().FoldTxBranch(txid)
 }
 
 // cancelTransaction will terminate a transaction branch along will all changes within it
 func (p *Proxy) cancelTransaction(txid string) {
-	p.GetRoot().DeleteTxBranch(txid)
+	p.getRoot().DeleteTxBranch(txid)
 }
 
 // CallbackFunction is a type used to define callback functions
@@ -522,15 +549,9 @@
 func (tuple *CallbackTuple) Execute(contextArgs []interface{}) interface{} {
 	args := []interface{}{}
 
-	for _, ta := range tuple.args {
-		args = append(args, ta)
-	}
+	args = append(args, tuple.args...)
 
-	if contextArgs != nil {
-		for _, ca := range contextArgs {
-			args = append(args, ca)
-		}
-	}
+	args = append(args, contextArgs...)
 
 	return tuple.callback(args...)
 }