MEDIUM: client native: adjust handling of errors when calling through interface

Author: oktalz

adapters/adapters.go

@@ -130,10 +130,12 @@ func ConfigVersionMiddleware(client clientnative.HAProxyClient) Adapter {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			qs := r.URL.Query()
 			tID := qs.Get("transaction_id")
-			configuration := client.Configuration()
+			configuration, err := client.Configuration()
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusNotImplemented)
+			}
 			tr, _ := configuration.GetTransaction(tID)
 			var v int64
-			var err error
 			if tr != nil && tr.Status == models.TransactionStatusInProgress {
 				v, err = configuration.GetConfigurationVersion(tr.ID)
 			} else {

configuration/cluster_sync.go

@@ -375,7 +375,10 @@ func (c *ClusterSync) issueJoinRequest(url, port, basePath string, registerPath
 		return err
 	}
 	if c.cfg.HAProxy.NodeIDFile != "" {
-		configuration := c.cli.Configuration()
+		configuration, errCfg := c.cli.Configuration()
+		if errCfg != nil {
+			return errCfg
+		}
 		// write id to file
 		errFID := ioutil.WriteFile(c.cfg.HAProxy.NodeIDFile, []byte(responseData.ID), 0644) // nolint:gosec
 		if errFID != nil {

configuration/cluster_sync_helpers.go

@@ -29,7 +29,11 @@ func (c *ClusterSync) getNodeFacts() map[string]string {
 		facts["dataplane_cmdline"] = c.cfg.Cmdline.String()
 	}
 
-	processInfos, err := c.cli.Runtime().GetInfo()
+	runtime, err := c.cli.Runtime()
+	if err != nil {
+		log.Errorf("unable to fetch processInfo: %s", err.Error())
+	}
+	processInfos, err := runtime.GetInfo()
 	if err != nil || len(processInfos) < 1 {
 		log.Error("unable to fetch processInfo")
 	} else {

configuration/map_sync.go

@@ -55,7 +55,12 @@ func (ms *MapSync) SyncAll(client client_native.HAProxyClient) {
 	for {
 		select {
 		case <-ticker.C:
-			maps, err := client.Runtime().ShowMaps()
+			runtime, err := client.Runtime()
+			if err != nil {
+				log.Warning("show maps sync error: ", err.Error())
+				continue
+			}
+			maps, err := runtime.ShowMaps()
 			if err != nil {
 				log.Warning("show maps sync error: ", err.Error())
 				continue
@@ -83,12 +88,16 @@ func (ms *MapSync) Sync(mp *models.Map, client client_native.HAProxyClient) (boo
 	if err != nil {
 		return false, fmt.Errorf("error reading map file: %s %s", mp.File, err.Error())
 	}
-	fileEntries := client.Runtime().ParseMapEntriesFromFile(rawFile, false)
+	runtime, err := client.Runtime()
+	if err != nil {
+		return false, fmt.Errorf("getting runtime entries error: id: %s %s", mp.ID, err.Error())
+	}
+	fileEntries := runtime.ParseMapEntriesFromFile(rawFile, false)
 	sort.Slice(fileEntries, func(i, j int) bool { return fileEntries[i].Key < fileEntries[j].Key })
 
 	// runtime map entries
 	id := fmt.Sprintf("#%s", mp.ID)
-	runtimeEntries, err := client.Runtime().ShowMapEntries(id)
+	runtimeEntries, err := runtime.ShowMapEntries(id)
 	if err != nil {
 		return false, fmt.Errorf("getting runtime entries error: id: %s %s", id, err.Error())
 	}

configure_data_plane.go

@@ -319,7 +319,12 @@ func configureAPI(api *operations.DataPlaneAPI) http.Handler {
 	if cfg.HAProxy.MaxOpenTransactions > 0 {
 		// creating the threshold limit using the CLI flag as hard quota and current open transactions as starting point
 		actualCount := func() uint64 {
-			ts, err := client.Configuration().GetTransactions(models.TransactionStatusInProgress)
+			configuration, err := client.Configuration()
+			if err != nil {
+				log.Errorf("Cannot retrieve current open transactions for rate limit, default to zero (%s)", err.Error())
+				return 0
+			}
+			ts, err := configuration.GetTransactions(models.TransactionStatusInProgress)
 			if err != nil {
 				log.Errorf("Cannot retrieve current open transactions for rate limit, default to zero (%s)", err.Error())
 				return 0
@@ -583,9 +588,13 @@ func configureAPI(api *operations.DataPlaneAPI) http.Handler {
 		return specification.NewGetSpecificationOK().WithPayload(&m)
 	})
 
+	configurationClient, err := client.Configuration()
+	if err != nil {
+		log.Fatal(err)
+	}
 	// set up service discovery handlers
 	discovery := service_discovery.NewServiceDiscoveries(service_discovery.ServiceDiscoveriesParams{
-		Client:      client.Configuration(),
+		Client:      configurationClient,
 		ReloadAgent: ra,
 		Context:     ctx,
 	})
@@ -619,16 +628,16 @@ func configureAPI(api *operations.DataPlaneAPI) http.Handler {
 
 	// create stored AWS instances
 	for _, data := range cfg.ServiceDiscovery.AWSRegions {
-		var err error
+		var errSD error
 
 		if data.ID == nil || len(*data.ID) == 0 {
 			data.ID = service_discovery.NewServiceDiscoveryUUID()
 		}
-		if err = service_discovery.ValidateAWSData(data, true); err != nil {
-			log.Fatalf("Error validating AWS instance: " + err.Error())
+		if errSD = service_discovery.ValidateAWSData(data, true); errSD != nil {
+			log.Fatalf("Error validating AWS instance: " + errSD.Error())
 		}
-		if err = discovery.AddNode("aws", *data.ID, data); err != nil {
-			log.Warning("Error creating AWS instance: " + err.Error())
+		if errSD = discovery.AddNode("aws", *data.ID, data); errSD != nil {
+			log.Warning("Error creating AWS instance: " + errSD.Error())
 		}
 	}
 	_ = cfg.SaveAWS(cfg.ServiceDiscovery.AWSRegions)
@@ -846,7 +855,7 @@ func configureNativeClient(cyx context.Context, haproxyOptions dataplaneapi_conf
 		log.Fatalf("error trying to use empty string for SPOE configuration directory")
 	}
 
-	client, err := client_native.New(context.Background(), opt...)
+	client, err := client_native.New(cyx, opt...)
 	if err != nil {
 		log.Fatalf("Error initializing configuration client: %v", err)
 	}
@@ -994,8 +1003,13 @@ func handleSignals(ctx context.Context, cancel context.CancelFunc, sigs chan os.
 				var clientCtx context.Context
 				cancel()
 				clientCtx, cancel = context.WithCancel(ctx)
-				client.ReplaceRuntime(configureRuntimeClient(clientCtx, client.Configuration(), haproxyOptions))
-				log.Info("Reloaded Data Plane API")
+				configuration, err := client.Configuration()
+				if err != nil {
+					log.Infof("Unable to reload Data Plane API: %s", err.Error())
+				} else {
+					client.ReplaceRuntime(configureRuntimeClient(clientCtx, configuration, haproxyOptions))
+					log.Info("Reloaded Data Plane API")
+				}
 			} else if sig == syscall.SIGUSR2 {
 				reloadConfigurationFile(client, haproxyOptions, users)
 			}
@@ -1022,7 +1036,12 @@ func reloadConfigurationFile(client client_native.HAProxyClient, haproxyOptions
 func startWatcher(ctx context.Context, client client_native.HAProxyClient, haproxyOptions dataplaneapi_config.HAProxyConfiguration, users *dataplaneapi_config.Users) error {
 	cb := func() {
 		reloadConfigurationFile(client, haproxyOptions, users)
-		if err := client.Configuration().IncrementVersion(); err != nil {
+		configuration, err := client.Configuration()
+		if err != nil {
+			log.Warningf("Failed to increment configuration version: %v", err)
+			return
+		}
+		if err := configuration.IncrementVersion(); err != nil {
 			log.Warningf("Failed to increment configuration version: %v", err)
 		}
 	}

go.mod

@@ -22,7 +22,7 @@ require (
 	github.com/go-openapi/validate v0.19.8
 	github.com/google/renameio v1.0.1
 	github.com/google/uuid v1.2.0
-	github.com/haproxytech/client-native/v3 v3.0.0-rc1.0.20220215222246-5a5df100599a
+	github.com/haproxytech/client-native/v3 v3.0.0
 	github.com/haproxytech/config-parser/v4 v4.0.0-rc2.0.20220215134434-54d66ef01d26
 	github.com/hashicorp/consul/api v1.6.0
 	github.com/hashicorp/hcl v1.0.0

go.sum

@@ -174,6 +174,8 @@ github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
 github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/haproxytech/client-native/v3 v3.0.0 h1:D3bx4ylnkKfRqDVFk15ZLcMyKVTgdgNN25NKAjb6LYo=
+github.com/haproxytech/client-native/v3 v3.0.0/go.mod h1:5qDnA7M1HmgJ/CTy6ByUomvnfgAgpH6R8NYZMdcMQ9k=
 github.com/haproxytech/config-parser/v4 v4.0.0-rc2.0.20220215134434-54d66ef01d26 h1:IWU3pWA4MzYzi0N5NDUgMf06V6bmXCsHok0hBMM1Zik=
 github.com/haproxytech/config-parser/v4 v4.0.0-rc2.0.20220215134434-54d66ef01d26/go.mod h1:pEuHx+aFhn0lIdvAg1OaawQfeRkpq1I8HzjtZN4/PLI=
 github.com/haproxytech/go-logger v1.0.1-0.20211022075555-178f1cdf4d84 h1:rSLHjJ4VGvMZcGAGQ9GaXuhvdswu1iLVXTThLX6OKN8=

handlers/acl.go

@@ -74,7 +74,13 @@ func (h *CreateACLHandlerImpl) Handle(params acl.CreateACLParams, principal inte
 		return acl.NewCreateACLDefault(int(*e.Code)).WithPayload(e)
 	}
 
-	err := h.Client.Configuration().CreateACL(params.ParentType, params.ParentName, params.Data, t, v)
+	configuration, err := h.Client.Configuration()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl.NewCreateACLDefault(int(*e.Code)).WithPayload(e)
+	}
+
+	err = configuration.CreateACL(params.ParentType, params.ParentName, params.Data, t, v)
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl.NewCreateACLDefault(int(*e.Code)).WithPayload(e)
@@ -115,8 +121,13 @@ func (h *DeleteACLHandlerImpl) Handle(params acl.DeleteACLParams, principal inte
 		}
 		return acl.NewDeleteACLDefault(int(*e.Code)).WithPayload(e)
 	}
+	configuration, err := h.Client.Configuration()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl.NewDeleteACLDefault(int(*e.Code)).WithPayload(e)
+	}
 
-	err := h.Client.Configuration().DeleteACL(params.Index, params.ParentType, params.ParentName, t, v)
+	err = configuration.DeleteACL(params.Index, params.ParentType, params.ParentName, t, v)
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl.NewDeleteACLDefault(int(*e.Code)).WithPayload(e)
@@ -143,7 +154,13 @@ func (h *GetACLHandlerImpl) Handle(params acl.GetACLParams, principal interface{
 		t = *params.TransactionID
 	}
 
-	v, rule, err := h.Client.Configuration().GetACL(params.Index, params.ParentType, params.ParentName, t)
+	configuration, err := h.Client.Configuration()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl.NewGetACLDefault(int(*e.Code)).WithPayload(e)
+	}
+
+	v, rule, err := configuration.GetACL(params.Index, params.ParentType, params.ParentName, t)
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl.NewGetACLDefault(int(*e.Code)).WithPayload(e)
@@ -163,7 +180,13 @@ func (h *GetAclsHandlerImpl) Handle(params acl.GetAclsParams, principal interfac
 		aclName = []string{*params.ACLName}
 	}
 
-	v, rules, err := h.Client.Configuration().GetACLs(params.ParentType, params.ParentName, t, aclName...)
+	configuration, err := h.Client.Configuration()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl.NewGetACLDefault(int(*e.Code)).WithPayload(e)
+	}
+
+	v, rules, err := configuration.GetACLs(params.ParentType, params.ParentName, t, aclName...)
 	if err != nil {
 		e := misc.HandleContainerGetError(err)
 		if *e.Code == misc.ErrHTTPOk {
@@ -195,7 +218,12 @@ func (h *ReplaceACLHandlerImpl) Handle(params acl.ReplaceACLParams, principal in
 		return acl.NewReplaceACLDefault(int(*e.Code)).WithPayload(e)
 	}
 
-	err := h.Client.Configuration().EditACL(params.Index, params.ParentType, params.ParentName, params.Data, t, v)
+	configuration, err := h.Client.Configuration()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl.NewReplaceACLDefault(int(*e.Code)).WithPayload(e)
+	}
+	err = configuration.EditACL(params.Index, params.ParentType, params.ParentName, params.Data, t, v)
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl.NewReplaceACLDefault(int(*e.Code)).WithPayload(e)

handlers/acl_runtime.go

@@ -12,8 +12,14 @@ type GetACLSHandlerRuntimeImpl struct {
 	Client client_native.HAProxyClient
 }
 
-func (g GetACLSHandlerRuntimeImpl) Handle(params acl_runtime.GetServicesHaproxyRuntimeAclsParams, i interface{}) middleware.Responder {
-	files, err := g.Client.Runtime().GetACLFiles()
+func (h GetACLSHandlerRuntimeImpl) Handle(params acl_runtime.GetServicesHaproxyRuntimeAclsParams, i interface{}) middleware.Responder {
+	runtime, err := h.Client.Runtime()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl_runtime.NewGetServicesHaproxyRuntimeAclsDefault(int(*e.Code)).WithPayload(e)
+	}
+
+	files, err := runtime.GetACLFiles()
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl_runtime.NewGetServicesHaproxyRuntimeAclsDefault(int(*e.Code)).WithPayload(e)
@@ -26,8 +32,14 @@ type GetACLHandlerRuntimeImpl struct {
 	Client client_native.HAProxyClient
 }
 
-func (g GetACLHandlerRuntimeImpl) Handle(params acl_runtime.GetServicesHaproxyRuntimeAclsIDParams, i interface{}) middleware.Responder {
-	aclFile, err := g.Client.Runtime().GetACLFile(params.ID)
+func (h GetACLHandlerRuntimeImpl) Handle(params acl_runtime.GetServicesHaproxyRuntimeAclsIDParams, i interface{}) middleware.Responder {
+	runtime, err := h.Client.Runtime()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl_runtime.NewGetServicesHaproxyRuntimeAclsIDDefault(int(*e.Code)).WithPayload(e)
+	}
+
+	aclFile, err := runtime.GetACLFile(params.ID)
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl_runtime.NewGetServicesHaproxyRuntimeAclsIDDefault(int(*e.Code)).WithPayload(e)
@@ -40,8 +52,13 @@ type GetACLFileEntriesHandlerRuntimeImpl struct {
 	Client client_native.HAProxyClient
 }
 
-func (g GetACLFileEntriesHandlerRuntimeImpl) Handle(params acl_runtime.GetServicesHaproxyRuntimeACLFileEntriesParams, i interface{}) middleware.Responder {
-	files, err := g.Client.Runtime().GetACLFilesEntries(params.ACLID)
+func (h GetACLFileEntriesHandlerRuntimeImpl) Handle(params acl_runtime.GetServicesHaproxyRuntimeACLFileEntriesParams, i interface{}) middleware.Responder {
+	runtime, err := h.Client.Runtime()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl_runtime.NewGetServicesHaproxyRuntimeACLFileEntriesDefault(int(*e.Code)).WithPayload(e)
+	}
+	files, err := runtime.GetACLFilesEntries(params.ACLID)
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl_runtime.NewGetServicesHaproxyRuntimeACLFileEntriesDefault(int(*e.Code)).WithPayload(e)
@@ -54,16 +71,21 @@ type PostACLFileEntryHandlerRuntimeImpl struct {
 	Client client_native.HAProxyClient
 }
 
-func (c PostACLFileEntryHandlerRuntimeImpl) Handle(params acl_runtime.PostServicesHaproxyRuntimeACLFileEntriesParams, i interface{}) middleware.Responder {
+func (h PostACLFileEntryHandlerRuntimeImpl) Handle(params acl_runtime.PostServicesHaproxyRuntimeACLFileEntriesParams, i interface{}) middleware.Responder {
 	var err error
+	runtime, err := h.Client.Runtime()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl_runtime.NewPostServicesHaproxyRuntimeACLFileEntriesDefault(int(*e.Code)).WithPayload(e)
+	}
 
-	if err = c.Client.Runtime().AddACLFileEntry(params.ACLID, params.Data.Value); err != nil {
+	if err = runtime.AddACLFileEntry(params.ACLID, params.Data.Value); err != nil {
 		e := misc.HandleError(err)
 		return acl_runtime.NewPostServicesHaproxyRuntimeACLFileEntriesDefault(int(*e.Code)).WithPayload(e)
 	}
 
 	var fileEntry *models.ACLFileEntry
-	fileEntry, err = c.Client.Runtime().GetACLFileEntry(params.ACLID, params.Data.Value)
+	fileEntry, err = runtime.GetACLFileEntry(params.ACLID, params.Data.Value)
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl_runtime.NewPostServicesHaproxyRuntimeACLFileEntriesDefault(int(*e.Code)).WithPayload(e)
@@ -76,8 +98,14 @@ type GetACLFileEntryRuntimeImpl struct {
 	Client client_native.HAProxyClient
 }
 
-func (g GetACLFileEntryRuntimeImpl) Handle(params acl_runtime.GetServicesHaproxyRuntimeACLFileEntriesIDParams, i interface{}) middleware.Responder {
-	fileEntry, err := g.Client.Runtime().GetACLFileEntry(params.ACLID, params.ID)
+func (h GetACLFileEntryRuntimeImpl) Handle(params acl_runtime.GetServicesHaproxyRuntimeACLFileEntriesIDParams, i interface{}) middleware.Responder {
+	runtime, err := h.Client.Runtime()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl_runtime.NewGetServicesHaproxyRuntimeACLFileEntriesIDDefault(int(*e.Code)).WithPayload(e)
+	}
+
+	fileEntry, err := runtime.GetACLFileEntry(params.ACLID, params.ID)
 	if err != nil {
 		e := misc.HandleError(err)
 		return acl_runtime.NewGetServicesHaproxyRuntimeACLFileEntriesIDDefault(int(*e.Code)).WithPayload(e)
@@ -90,8 +118,13 @@ type DeleteACLFileEntryHandlerRuntimeImpl struct {
 	Client client_native.HAProxyClient
 }
 
-func (d DeleteACLFileEntryHandlerRuntimeImpl) Handle(params acl_runtime.DeleteServicesHaproxyRuntimeACLFileEntriesIDParams, i interface{}) middleware.Responder {
-	if err := d.Client.Runtime().DeleteACLFileEntry(params.ACLID, "#"+params.ID); err != nil {
+func (h DeleteACLFileEntryHandlerRuntimeImpl) Handle(params acl_runtime.DeleteServicesHaproxyRuntimeACLFileEntriesIDParams, i interface{}) middleware.Responder {
+	runtime, err := h.Client.Runtime()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl_runtime.NewDeleteServicesHaproxyRuntimeACLFileEntriesIDDefault(int(*e.Code)).WithPayload(e)
+	}
+	if err := runtime.DeleteACLFileEntry(params.ACLID, "#"+params.ID); err != nil {
 		e := misc.HandleError(err)
 		return acl_runtime.NewDeleteServicesHaproxyRuntimeACLFileEntriesIDDefault(int(*e.Code)).WithPayload(e)
 	}
@@ -103,8 +136,14 @@ type ACLRuntimeAddPayloadRuntimeACLHandlerImpl struct {
 	Client client_native.HAProxyClient
 }
 
-func (a ACLRuntimeAddPayloadRuntimeACLHandlerImpl) Handle(params acl_runtime.AddPayloadRuntimeACLParams, i interface{}) middleware.Responder {
-	err := a.Client.Runtime().AddACLAtomic(params.ACLID, params.Data)
+func (h ACLRuntimeAddPayloadRuntimeACLHandlerImpl) Handle(params acl_runtime.AddPayloadRuntimeACLParams, i interface{}) middleware.Responder {
+	runtime, err := h.Client.Runtime()
+	if err != nil {
+		e := misc.HandleError(err)
+		return acl_runtime.NewAddPayloadRuntimeACLDefault(int(*e.Code)).WithPayload(e)
+	}
+
+	err = runtime.AddACLAtomic(params.ACLID, params.Data)
 	if err != nil {
 		status := misc.GetHTTPStatusFromErr(err)
 		return acl_runtime.NewAddPayloadRuntimeACLDefault(status).WithPayload(misc.SetError(status, err.Error()))