@@ -297,8 +297,8 @@ func (c *controller) agentInit(listenAddr, bindAddrOrInterface, advertiseAddr, d

 		return err

 	}

-	// Register the diagnose handlers

-	c.DiagnoseServer.RegisterHandler(nDB, networkdb.NetDbPaths2Func)

+	// Register the diagnostic handlers

+	c.DiagnosticServer.RegisterHandler(nDB, networkdb.NetDbPaths2Func)

 	var cancelList []func()

 	ch, cancel := nDB.Watch(libnetworkEPTable, "", "")

@@ -61,7 +61,7 @@ import (

 	"github.com/docker/libnetwork/cluster"

 	"github.com/docker/libnetwork/config"

 	"github.com/docker/libnetwork/datastore"

-	"github.com/docker/libnetwork/diagnose"

+	"github.com/docker/libnetwork/diagnostic"

 	"github.com/docker/libnetwork/discoverapi"

 	"github.com/docker/libnetwork/driverapi"

 	"github.com/docker/libnetwork/drvregistry"

@@ -136,12 +136,12 @@ type NetworkController interface {

 	// SetKeys configures the encryption key for gossip and overlay data path

 	SetKeys(keys []*types.EncryptionKey) error

-	// StartDiagnose start the network diagnose mode

-	StartDiagnose(port int)

-	// StopDiagnose start the network diagnose mode

-	StopDiagnose()

-	// IsDiagnoseEnabled returns true if the diagnose is enabled

-	IsDiagnoseEnabled() bool

+	// StartDiagnostic start the network diagnostic mode

+	StartDiagnostic(port int)

+	// StopDiagnostic start the network diagnostic mode

+	StopDiagnostic()

+	// IsDiagnosticEnabled returns true if the diagnostic is enabled

+	IsDiagnosticEnabled() bool

 }

 // NetworkWalker is a client provided function which will be used to walk the Networks.

@@ -176,7 +176,7 @@ type controller struct {

 	agentStopDone          chan struct{}

 	keys                   []*types.EncryptionKey

 	clusterConfigAvailable bool

-	DiagnoseServer         *diagnose.Server

+	DiagnosticServer       *diagnostic.Server

 	sync.Mutex

 }

@@ -188,16 +188,16 @@ type initializer struct {

 // New creates a new instance of network controller.

 func New(cfgOptions ...config.Option) (NetworkController, error) {

 	c := &controller{

-		id:              stringid.GenerateRandomID(),

-		cfg:             config.ParseConfigOptions(cfgOptions...),

-		sandboxes:       sandboxTable{},

-		svcRecords:      make(map[string]svcInfo),

-		serviceBindings: make(map[serviceKey]*service),

-		agentInitDone:   make(chan struct{}),

-		networkLocker:   locker.New(),

-		DiagnoseServer:  diagnose.New(),

+		id:               stringid.GenerateRandomID(),

+		cfg:              config.ParseConfigOptions(cfgOptions...),

+		sandboxes:        sandboxTable{},

+		svcRecords:       make(map[string]svcInfo),

+		serviceBindings:  make(map[serviceKey]*service),

+		agentInitDone:    make(chan struct{}),

+		networkLocker:    locker.New(),

+		DiagnosticServer: diagnostic.New(),

 	}

-	c.DiagnoseServer.Init()

+	c.DiagnosticServer.Init()

 	if err := c.initStores(); err != nil {

 		return nil, err

@@ -1307,27 +1307,27 @@ func (c *controller) Stop() {

 	osl.GC()

 }

-// StartDiagnose start the network diagnose mode

-func (c *controller) StartDiagnose(port int) {

+// StartDiagnostic start the network dias mode

+func (c *controller) StartDiagnostic(port int) {

 	c.Lock()

-	if !c.DiagnoseServer.IsDebugEnable() {

-		c.DiagnoseServer.EnableDebug("127.0.0.1", port)

+	if !c.DiagnosticServer.IsDiagnosticEnabled() {

+		c.DiagnosticServer.EnableDiagnostic("127.0.0.1", port)

 	}

 	c.Unlock()

 }

-// StopDiagnose start the network diagnose mode

-func (c *controller) StopDiagnose() {

+// StopDiagnostic start the network dias mode

+func (c *controller) StopDiagnostic() {

 	c.Lock()

-	if c.DiagnoseServer.IsDebugEnable() {

-		c.DiagnoseServer.DisableDebug()

+	if c.DiagnosticServer.IsDiagnosticEnabled() {

+		c.DiagnosticServer.DisableDiagnostic()

 	}

 	c.Unlock()

 }

-// IsDiagnoseEnabled returns true if the diagnose is enabled

-func (c *controller) IsDiagnoseEnabled() bool {

+// IsDiagnosticEnabled returns true if the dias is enabled

+func (c *controller) IsDiagnosticEnabled() bool {

 	c.Lock()

 	defer c.Unlock()

-	return c.DiagnoseServer.IsDebugEnable()

+	return c.DiagnosticServer.IsDiagnosticEnabled()

 }

deleted file mode 100644

@@ -1,227 +0,0 @@

-package diagnose

-

-import (

-	"context"

-	"encoding/json"

-	"fmt"

-	"net/http"

-	"sync"

-	"sync/atomic"

-

-	stackdump "github.com/docker/docker/pkg/signal"

-	"github.com/docker/libnetwork/common"

-	"github.com/sirupsen/logrus"

-)

-

-// HTTPHandlerFunc TODO

-type HTTPHandlerFunc func(interface{}, http.ResponseWriter, *http.Request)

-

-type httpHandlerCustom struct {

-	ctx interface{}

-	F   func(interface{}, http.ResponseWriter, *http.Request)

-}

-

-// ServeHTTP TODO

-func (h httpHandlerCustom) ServeHTTP(w http.ResponseWriter, r *http.Request) {

-	h.F(h.ctx, w, r)

-}

-

-var diagPaths2Func = map[string]HTTPHandlerFunc{

-	"/":          notImplemented,

-	"/help":      help,

-	"/ready":     ready,

-	"/stackdump": stackTrace,

-}

-

-// Server when the debug is enabled exposes a

-// This data structure is protected by the Agent mutex so does not require and additional mutex here

-type Server struct {

-	enable            int32

-	srv               *http.Server

-	port              int

-	mux               *http.ServeMux

-	registeredHanders map[string]bool

-	sync.Mutex

-}

-

-// New creates a new diagnose server

-func New() *Server {

-	return &Server{

-		registeredHanders: make(map[string]bool),

-	}

-}

-

-// Init initialize the mux for the http handling and register the base hooks

-func (s *Server) Init() {

-	s.mux = http.NewServeMux()

-

-	// Register local handlers

-	s.RegisterHandler(s, diagPaths2Func)

-}

-

-// RegisterHandler allows to register new handlers to the mux and to a specific path

-func (s *Server) RegisterHandler(ctx interface{}, hdlrs map[string]HTTPHandlerFunc) {

-	s.Lock()

-	defer s.Unlock()

-	for path, fun := range hdlrs {

-		if _, ok := s.registeredHanders[path]; ok {

-			continue

-		}

-		s.mux.Handle(path, httpHandlerCustom{ctx, fun})

-		s.registeredHanders[path] = true

-	}

-}

-

-// ServeHTTP this is the method called bu the ListenAndServe, and is needed to allow us to

-// use our custom mux

-func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {

-	s.mux.ServeHTTP(w, r)

-}

-

-// EnableDebug opens a TCP socket to debug the passed network DB

-func (s *Server) EnableDebug(ip string, port int) {

-	s.Lock()

-	defer s.Unlock()

-

-	s.port = port

-

-	if s.enable == 1 {

-		logrus.Info("The server is already up and running")

-		return

-	}

-

-	logrus.Infof("Starting the diagnose server listening on %d for commands", port)

-	srv := &http.Server{Addr: fmt.Sprintf("%s:%d", ip, port), Handler: s}

-	s.srv = srv

-	s.enable = 1

-	go func(n *Server) {

-		// Ingore ErrServerClosed that is returned on the Shutdown call

-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {

-			logrus.Errorf("ListenAndServe error: %s", err)

-			atomic.SwapInt32(&n.enable, 0)

-		}

-	}(s)

-}

-

-// DisableDebug stop the dubug and closes the tcp socket

-func (s *Server) DisableDebug() {

-	s.Lock()

-	defer s.Unlock()

-

-	s.srv.Shutdown(context.Background())

-	s.srv = nil

-	s.enable = 0

-	logrus.Info("Disabling the diagnose server")

-}

-

-// IsDebugEnable returns true when the debug is enabled

-func (s *Server) IsDebugEnable() bool {

-	s.Lock()

-	defer s.Unlock()

-	return s.enable == 1

-}

-

-func notImplemented(ctx interface{}, w http.ResponseWriter, r *http.Request) {

-	r.ParseForm()

-	_, json := ParseHTTPFormOptions(r)

-	rsp := WrongCommand("not implemented", fmt.Sprintf("URL path: %s no method implemented check /help\n", r.URL.Path))

-

-	// audit logs

-	log := logrus.WithFields(logrus.Fields{"component": "diagnose", "remoteIP": r.RemoteAddr, "method": common.CallerName(0), "url": r.URL.String()})

-	log.Info("command not implemented done")

-

-	HTTPReply(w, rsp, json)

-}

-

-func help(ctx interface{}, w http.ResponseWriter, r *http.Request) {

-	r.ParseForm()

-	_, json := ParseHTTPFormOptions(r)

-

-	// audit logs

-	log := logrus.WithFields(logrus.Fields{"component": "diagnose", "remoteIP": r.RemoteAddr, "method": common.CallerName(0), "url": r.URL.String()})

-	log.Info("help done")

-

-	n, ok := ctx.(*Server)

-	var result string

-	if ok {

-		for path := range n.registeredHanders {

-			result += fmt.Sprintf("%s\n", path)

-		}

-		HTTPReply(w, CommandSucceed(&StringCmd{Info: result}), json)

-	}

-}

-

-func ready(ctx interface{}, w http.ResponseWriter, r *http.Request) {

-	r.ParseForm()

-	_, json := ParseHTTPFormOptions(r)

-

-	// audit logs

-	log := logrus.WithFields(logrus.Fields{"component": "diagnose", "remoteIP": r.RemoteAddr, "method": common.CallerName(0), "url": r.URL.String()})

-	log.Info("ready done")

-	HTTPReply(w, CommandSucceed(&StringCmd{Info: "OK"}), json)

-}

-

-func stackTrace(ctx interface{}, w http.ResponseWriter, r *http.Request) {

-	r.ParseForm()

-	_, json := ParseHTTPFormOptions(r)

-

-	// audit logs

-	log := logrus.WithFields(logrus.Fields{"component": "diagnose", "remoteIP": r.RemoteAddr, "method": common.CallerName(0), "url": r.URL.String()})

-	log.Info("stack trace")

-

-	path, err := stackdump.DumpStacks("/tmp/")

-	if err != nil {

-		log.WithError(err).Error("failed to write goroutines dump")

-		HTTPReply(w, FailCommand(err), json)

-	} else {

-		log.Info("stack trace done")

-		HTTPReply(w, CommandSucceed(&StringCmd{Info: fmt.Sprintf("goroutine stacks written to %s", path)}), json)

-	}

-}

-

-// DebugHTTPForm helper to print the form url parameters

-func DebugHTTPForm(r *http.Request) {

-	for k, v := range r.Form {

-		logrus.Debugf("Form[%q] = %q\n", k, v)

-	}

-}

-

-// JSONOutput contains details on JSON output printing

-type JSONOutput struct {

-	enable      bool

-	prettyPrint bool

-}

-

-// ParseHTTPFormOptions easily parse the JSON printing options

-func ParseHTTPFormOptions(r *http.Request) (bool, *JSONOutput) {

-	_, unsafe := r.Form["unsafe"]

-	v, json := r.Form["json"]

-	var pretty bool

-	if len(v) > 0 {

-		pretty = v[0] == "pretty"

-	}

-	return unsafe, &JSONOutput{enable: json, prettyPrint: pretty}

-}

-

-// HTTPReply helper function that takes care of sending the message out

-func HTTPReply(w http.ResponseWriter, r *HTTPResult, j *JSONOutput) (int, error) {

-	var response []byte

-	if j.enable {

-		w.Header().Set("Content-Type", "application/json")

-		var err error

-		if j.prettyPrint {

-			response, err = json.MarshalIndent(r, "", "  ")

-			if err != nil {

-				response, _ = json.MarshalIndent(FailCommand(err), "", "  ")

-			}

-		} else {

-			response, err = json.Marshal(r)

-			if err != nil {

-				response, _ = json.Marshal(FailCommand(err))

-			}

-		}

-	} else {

-		response = []byte(r.String())

-	}

-	return fmt.Fprint(w, string(response))

-}

deleted file mode 100644

@@ -1,122 +0,0 @@

-package diagnose

-

-import "fmt"

-

-// StringInterface interface that has to be implemented by messages

-type StringInterface interface {

-	String() string

-}

-

-// CommandSucceed creates a success message

-func CommandSucceed(result StringInterface) *HTTPResult {

-	return &HTTPResult{

-		Message: "OK",

-		Details: result,

-	}

-}

-

-// FailCommand creates a failure message with error

-func FailCommand(err error) *HTTPResult {

-	return &HTTPResult{

-		Message: "FAIL",

-		Details: &ErrorCmd{Error: err.Error()},

-	}

-}

-

-// WrongCommand creates a wrong command response

-func WrongCommand(message, usage string) *HTTPResult {

-	return &HTTPResult{

-		Message: message,

-		Details: &UsageCmd{Usage: usage},

-	}

-}

-

-// HTTPResult Diagnose Server HTTP result operation

-type HTTPResult struct {

-	Message string          `json:"message"`

-	Details StringInterface `json:"details"`

-}

-

-func (h *HTTPResult) String() string {

-	rsp := h.Message

-	if h.Details != nil {

-		rsp += "\n" + h.Details.String()

-	}

-	return rsp

-}

-

-// UsageCmd command with usage field

-type UsageCmd struct {

-	Usage string `json:"usage"`

-}

-

-func (u *UsageCmd) String() string {

-	return "Usage: " + u.Usage

-}

-

-// StringCmd command with info string

-type StringCmd struct {

-	Info string `json:"info"`

-}

-

-func (s *StringCmd) String() string {

-	return s.Info

-}

-

-// ErrorCmd command with error

-type ErrorCmd struct {

-	Error string `json:"error"`

-}

-

-func (e *ErrorCmd) String() string {

-	return "Error: " + e.Error

-}

-

-// TableObj network db table object

-type TableObj struct {

-	Length   int               `json:"size"`

-	Elements []StringInterface `json:"entries"`

-}

-

-func (t *TableObj) String() string {

-	output := fmt.Sprintf("total entries: %d\n", t.Length)

-	for _, e := range t.Elements {

-		output += e.String()

-	}

-	return output

-}

-

-// PeerEntryObj entry in the networkdb peer table

-type PeerEntryObj struct {

-	Index int    `json:"-"`

-	Name  string `json:"-=name"`

-	IP    string `json:"ip"`

-}

-

-func (p *PeerEntryObj) String() string {

-	return fmt.Sprintf("%d) %s -> %s\n", p.Index, p.Name, p.IP)

-}

-

-// TableEntryObj network db table entry object

-type TableEntryObj struct {

-	Index int    `json:"-"`

-	Key   string `json:"key"`

-	Value string `json:"value"`

-	Owner string `json:"owner"`

-}

-

-func (t *TableEntryObj) String() string {

-	return fmt.Sprintf("%d) k:`%s` -> v:`%s` owner:`%s`\n", t.Index, t.Key, t.Value, t.Owner)

-}

-

-// TableEndpointsResult fully typed message for proper unmarshaling on the client side

-type TableEndpointsResult struct {

-	TableObj

-	Elements []TableEntryObj `json:"entries"`

-}

-

-// TablePeersResult fully typed message for proper unmarshaling on the client side

-type TablePeersResult struct {

-	TableObj

-	Elements []PeerEntryObj `json:"entries"`

-}

new file mode 100644

@@ -0,0 +1,227 @@

+package diagnostic

+

+import (

+	"context"

+	"encoding/json"

+	"fmt"

+	"net/http"

+	"sync"

+	"sync/atomic"

+

+	stackdump "github.com/docker/docker/pkg/signal"

+	"github.com/docker/libnetwork/common"

+	"github.com/sirupsen/logrus"

+)

+

+// HTTPHandlerFunc TODO

+type HTTPHandlerFunc func(interface{}, http.ResponseWriter, *http.Request)

+

+type httpHandlerCustom struct {

+	ctx interface{}

+	F   func(interface{}, http.ResponseWriter, *http.Request)

+}

+

+// ServeHTTP TODO

+func (h httpHandlerCustom) ServeHTTP(w http.ResponseWriter, r *http.Request) {

+	h.F(h.ctx, w, r)

+}

+

+var diagPaths2Func = map[string]HTTPHandlerFunc{

+	"/":          notImplemented,

+	"/help":      help,

+	"/ready":     ready,

+	"/stackdump": stackTrace,

+}

+

+// Server when the debug is enabled exposes a

+// This data structure is protected by the Agent mutex so does not require and additional mutex here

+type Server struct {

+	enable            int32

+	srv               *http.Server

+	port              int

+	mux               *http.ServeMux

+	registeredHanders map[string]bool

+	sync.Mutex

+}

+

+// New creates a new diagnostic server

+func New() *Server {

+	return &Server{

+		registeredHanders: make(map[string]bool),

+	}

+}

+

+// Init initialize the mux for the http handling and register the base hooks

+func (s *Server) Init() {

+	s.mux = http.NewServeMux()

+

+	// Register local handlers

+	s.RegisterHandler(s, diagPaths2Func)

+}

+

+// RegisterHandler allows to register new handlers to the mux and to a specific path

+func (s *Server) RegisterHandler(ctx interface{}, hdlrs map[string]HTTPHandlerFunc) {

+	s.Lock()

+	defer s.Unlock()

+	for path, fun := range hdlrs {

+		if _, ok := s.registeredHanders[path]; ok {

+			continue

+		}

+		s.mux.Handle(path, httpHandlerCustom{ctx, fun})

+		s.registeredHanders[path] = true

+	}

+}

+

+// ServeHTTP this is the method called bu the ListenAndServe, and is needed to allow us to

+// use our custom mux

+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {

+	s.mux.ServeHTTP(w, r)

+}

+

+// EnableDiagnostic opens a TCP socket to debug the passed network DB

+func (s *Server) EnableDiagnostic(ip string, port int) {

+	s.Lock()

+	defer s.Unlock()

+

+	s.port = port

+

+	if s.enable == 1 {

+		logrus.Info("The server is already up and running")

+		return

+	}

+

+	logrus.Infof("Starting the diagnostic server listening on %d for commands", port)

+	srv := &http.Server{Addr: fmt.Sprintf("%s:%d", ip, port), Handler: s}

+	s.srv = srv

+	s.enable = 1

+	go func(n *Server) {

+		// Ingore ErrServerClosed that is returned on the Shutdown call

+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {

+			logrus.Errorf("ListenAndServe error: %s", err)

+			atomic.SwapInt32(&n.enable, 0)

+		}

+	}(s)

+}

+

+// DisableDiagnostic stop the dubug and closes the tcp socket

+func (s *Server) DisableDiagnostic() {

+	s.Lock()

+	defer s.Unlock()

+

+	s.srv.Shutdown(context.Background())

+	s.srv = nil

+	s.enable = 0

+	logrus.Info("Disabling the diagnostic server")

+}

+

+// IsDiagnosticEnabled returns true when the debug is enabled

+func (s *Server) IsDiagnosticEnabled() bool {

+	s.Lock()

+	defer s.Unlock()

+	return s.enable == 1

+}

+

+func notImplemented(ctx interface{}, w http.ResponseWriter, r *http.Request) {

+	r.ParseForm()

+	_, json := ParseHTTPFormOptions(r)

+	rsp := WrongCommand("not implemented", fmt.Sprintf("URL path: %s no method implemented check /help\n", r.URL.Path))

+

+	// audit logs

+	log := logrus.WithFields(logrus.Fields{"component": "diagnostic", "remoteIP": r.RemoteAddr, "method": common.CallerName(0), "url": r.URL.String()})

+	log.Info("command not implemented done")

+

+	HTTPReply(w, rsp, json)

+}

+

+func help(ctx interface{}, w http.ResponseWriter, r *http.Request) {

+	r.ParseForm()

+	_, json := ParseHTTPFormOptions(r)

+

+	// audit logs

+	log := logrus.WithFields(logrus.Fields{"component": "diagnostic", "remoteIP": r.RemoteAddr, "method": common.CallerName(0), "url": r.URL.String()})

+	log.Info("help done")

+

+	n, ok := ctx.(*Server)

+	var result string

+	if ok {

+		for path := range n.registeredHanders {

+			result += fmt.Sprintf("%s\n", path)

+		}

+		HTTPReply(w, CommandSucceed(&StringCmd{Info: result}), json)

+	}

+}

+

+func ready(ctx interface{}, w http.ResponseWriter, r *http.Request) {

+	r.ParseForm()

+	_, json := ParseHTTPFormOptions(r)

+

+	// audit logs

+	log := logrus.WithFields(logrus.Fields{"component": "diagnostic", "remoteIP": r.RemoteAddr, "method": common.CallerName(0), "url": r.URL.String()})

+	log.Info("ready done")

+	HTTPReply(w, CommandSucceed(&StringCmd{Info: "OK"}), json)

+}

+

+func stackTrace(ctx interface{}, w http.ResponseWriter, r *http.Request) {

+	r.ParseForm()

+	_, json := ParseHTTPFormOptions(r)

+

+	// audit logs

+	log := logrus.WithFields(logrus.Fields{"component": "diagnostic", "remoteIP": r.RemoteAddr, "method": common.CallerName(0), "url": r.URL.String()})

+	log.Info("stack trace")

+

+	path, err := stackdump.DumpStacks("/tmp/")

+	if err != nil {

+		log.WithError(err).Error("failed to write goroutines dump")

+		HTTPReply(w, FailCommand(err), json)

+	} else {

+		log.Info("stack trace done")

+		HTTPReply(w, CommandSucceed(&StringCmd{Info: fmt.Sprintf("goroutine stacks written to %s", path)}), json)

+	}

+}

+

+// DebugHTTPForm helper to print the form url parameters

+func DebugHTTPForm(r *http.Request) {

+	for k, v := range r.Form {

+		logrus.Debugf("Form[%q] = %q\n", k, v)

+	}

+}

+

+// JSONOutput contains details on JSON output printing

+type JSONOutput struct {

+	enable      bool

+	prettyPrint bool

+}

+

+// ParseHTTPFormOptions easily parse the JSON printing options

+func ParseHTTPFormOptions(r *http.Request) (bool, *JSONOutput) {

+	_, unsafe := r.Form["unsafe"]

+	v, json := r.Form["json"]

+	var pretty bool

+	if len(v) > 0 {

+		pretty = v[0] == "pretty"

+	}

+	return unsafe, &JSONOutput{enable: json, prettyPrint: pretty}

+}

+

+// HTTPReply helper function that takes care of sending the message out

+func HTTPReply(w http.ResponseWriter, r *HTTPResult, j *JSONOutput) (int, error) {

+	var response []byte

+	if j.enable {

+		w.Header().Set("Content-Type", "application/json")

+		var err error

+		if j.prettyPrint {

+			response, err = json.MarshalIndent(r, "", "  ")

+			if err != nil {

+				response, _ = json.MarshalIndent(FailCommand(err), "", "  ")

+			}

+		} else {

+			response, err = json.Marshal(r)

+			if err != nil {

+				response, _ = json.Marshal(FailCommand(err))

+			}

+		}

+	} else {

+		response = []byte(r.String())

+	}

+	return fmt.Fprint(w, string(response))

+}

new file mode 100644

@@ -0,0 +1,122 @@

+package diagnostic

+

+import "fmt"

+

+// StringInterface interface that has to be implemented by messages

+type StringInterface interface {

+	String() string

+}

+

+// CommandSucceed creates a success message

+func CommandSucceed(result StringInterface) *HTTPResult {

+	return &HTTPResult{

+		Message: "OK",

+		Details: result,

+	}

+}

+

+// FailCommand creates a failure message with error

+func FailCommand(err error) *HTTPResult {

+	return &HTTPResult{

+		Message: "FAIL",

+		Details: &ErrorCmd{Error: err.Error()},

+	}

+}

+

+// WrongCommand creates a wrong command response

+func WrongCommand(message, usage string) *HTTPResult {

+	return &HTTPResult{

+		Message: message,

+		Details: &UsageCmd{Usage: usage},

+	}

+}

+

+// HTTPResult Diagnostic Server HTTP result operation

+type HTTPResult struct {

+	Message string          `json:"message"`

+	Details StringInterface `json:"details"`

+}

+

+func (h *HTTPResult) String() string {

+	rsp := h.Message

+	if h.Details != nil {

+		rsp += "\n" + h.Details.String()

+	}

+	return rsp

+}

+

+// UsageCmd command with usage field

+type UsageCmd struct {

+	Usage string `json:"usage"`

+}

+

+func (u *UsageCmd) String() string {

+	return "Usage: " + u.Usage

+}

+

+// StringCmd command with info string

+type StringCmd struct {

+	Info string `json:"info"`

+}

+

+func (s *StringCmd) String() string {

+	return s.Info

+}

+

+// ErrorCmd command with error

+type ErrorCmd struct {

+	Error string `json:"error"`

+}

+

+func (e *ErrorCmd) String() string {

+	return "Error: " + e.Error

+}

+

+// TableObj network db table object

+type TableObj struct {

+	Length   int               `json:"size"`

+	Elements []StringInterface `json:"entries"`

+}

+

+func (t *TableObj) String() string {

+	output := fmt.Sprintf("total entries: %d\n", t.Length)

+	for _, e := range t.Elements {

+		output += e.String()

+	}

+	return output

+}

+

+// PeerEntryObj entry in the networkdb peer table

+type PeerEntryObj struct {

+	Index int    `json:"-"`

+	Name  string `json:"-=name"`

+	IP    string `json:"ip"`

+}

+

+func (p *PeerEntryObj) String() string {

+	return fmt.Sprintf("%d) %s -> %s\n", p.Index, p.Name, p.IP)

+}

+

+// TableEntryObj network db table entry object

+type TableEntryObj struct {

+	Index int    `json:"-"`

+	Key   string `json:"key"`

+	Value string `json:"value"`

+	Owner string `json:"owner"`

+}

+

+func (t *TableEntryObj) String() string {

+	return fmt.Sprintf("%d) k:`%s` -> v:`%s` owner:`%s`\n", t.Index, t.Key, t.Value, t.Owner)

+}

+

+// TableEndpointsResult fully typed message for proper unmarshaling on the client side

+type TableEndpointsResult struct {

+	TableObj

+	Elements []TableEntryObj `json:"entries"`

+}

+

+// TablePeersResult fully typed message for proper unmarshaling on the client side

+type TablePeersResult struct {

+	TableObj

+	Elements []PeerEntryObj `json:"entries"`

+}

@@ -328,6 +328,9 @@ func (nDB *NetworkDB) GetEntry(tname, nid, key string) ([]byte, error) {

 	if err != nil {

 		return nil, err

 	}

+	if entry != nil && entry.deleting {

+		return nil, types.NotFoundErrorf("entry in table %s network id %s and key %s deleted and pending garbage collection", tname, nid, key)

+	}

 	return entry.value, nil

 }

@@ -7,6 +7,7 @@ import (

 	"log"

 	"net"

 	"os"

+	"strings"

 	"sync/atomic"

 	"testing"

 	"time"

@@ -446,6 +447,12 @@ func TestNetworkDBCRUDMediumCluster(t *testing.T) {

 		dbs[i].verifyEntryExistence(t, "test_table", "network1", "test_key", "", false)

 	}

+	for i := 1; i < n; i++ {

+		_, err = dbs[i].GetEntry("test_table", "network1", "test_key")

+		assert.Error(t, err)

+		assert.True(t, strings.Contains(err.Error(), "deleted and pending garbage collection"))

+	}

+

 	closeNetworkDBInstances(dbs)

 }

deleted file mode 100644

@@ -1,409 +0,0 @@

-package networkdb

-

-import (

-	"encoding/base64"

-	"fmt"

-	"net/http"

-	"strings"

-

-	"github.com/docker/libnetwork/common"

-	"github.com/docker/libnetwork/diagnose"

-	"github.com/sirupsen/logrus"

-)

-

-const (

-	missingParameter = "missing parameter"

-	dbNotAvailable   = "database not available"

-)

-

-// NetDbPaths2Func TODO

-var NetDbPaths2Func = map[string]diagnose.HTTPHandlerFunc{