LBAAS-142: add lbaas/v2 bindings

CHANGELOG.md

@@ -28,6 +28,7 @@ Some examples, more below in the actual changelog (newer entries are more likely
 ### Added
 * core/v1: add `created_at` and `updated_at` fields to Resource type
 * generic client: make common.PartialResource filterable
+* lbaas/v2: added new `Cluster`, `Node` & `LoadBalancer` resources (#309, @anx-mschaefer)
 
 ## [0.5.3] - 2023-06-16
 

pkg/apis/common/gs/common.go

@@ -3,8 +3,10 @@ package gs
 import (
 	"bytes"
 	"context"
+	"go.anx.io/go-anxcloud/pkg/utils/object/filter"
 	"io"
 	"net/http"
+	"net/url"
 
 	"go.anx.io/go-anxcloud/pkg/api/types"
 )
@@ -30,3 +32,50 @@ func (gs *GenericService) FilterAPIResponse(ctx context.Context, res *http.Respo
 	}
 	return res, nil
 }
+
+// RequestBody prevents decoding of delete responses as they are not compatible with the
+// objects type
+func RequestBody(ctx context.Context, br func() interface{}) (interface{}, error) {
+	op, err := types.OperationFromContext(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if op == types.OperationCreate || op == types.OperationUpdate {
+		response := br()
+
+		return response, nil
+	}
+
+	return nil, nil
+}
+
+// EndpointURL is a helper function which can be wrapped by API bindings to enable the filter helper
+func EndpointURL(ctx context.Context, obj types.Object, resourcePath string) (*url.URL, error) {
+	op, err := types.OperationFromContext(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	u, err := url.Parse(resourcePath)
+	if err != nil {
+		return nil, err
+	}
+
+	if op == types.OperationList {
+		helper, err := filter.NewHelper(obj)
+		if err != nil {
+			return nil, err
+		}
+
+		filters := helper.BuildQuery().Encode()
+
+		if filters != "" {
+			query := u.Query()
+			query.Set("filters", filters)
+			u.RawQuery = query.Encode()
+		}
+	}
+
+	return u, nil
+}

pkg/apis/lbaas/v2/common.go

@@ -0,0 +1,7 @@
+package v2
+
+// commonRequestBody is used to optionally omit the `State` field on create and update
+// by embedding it to the request in the FilterAPIRequestBody hook
+type commonRequestBody struct {
+	State string `json:"state,omitempty"`
+}

pkg/apis/lbaas/v2/lb_cluster_genclient.go

@@ -0,0 +1,24 @@
+package v2
+
+import (
+	"context"
+	"go.anx.io/go-anxcloud/pkg/apis/common/gs"
+	"net/url"
+)
+
+// FilterAPIRequestBody adds the CommonRequestBody
+func (c *Cluster) FilterAPIRequestBody(ctx context.Context) (interface{}, error) {
+	return gs.RequestBody(ctx, func() interface{} {
+		return &struct {
+			commonRequestBody
+			Cluster
+		}{
+			Cluster: *c,
+		}
+	})
+}
+
+// EndpointURL returns the common URL for operations on the Cluster resource
+func (c *Cluster) EndpointURL(ctx context.Context) (*url.URL, error) {
+	return gs.EndpointURL(ctx, c, "/api/LBaaSv2/v1/clusters.json")
+}

pkg/apis/lbaas/v2/lb_cluster_types.go

@@ -0,0 +1,26 @@
+package v2
+
+import (
+	"go.anx.io/go-anxcloud/pkg/apis/common/gs"
+)
+
+type LoadBalancerImplementation string
+
+const (
+	LoadBalancerImplementationHAProxy LoadBalancerImplementation = "haproxy"
+)
+
+// anxcloud:object
+
+// Cluster holds the information of a load balancing cluster
+type Cluster struct {
+	gs.GenericService
+	gs.HasState
+
+	Identifier       string                     `json:"identifier,omitempty" anxcloud:"identifier"`
+	Name             string                     `json:"name,omitempty"`
+	Implementation   LoadBalancerImplementation `json:"implementation,omitempty"`
+	FrontendPrefixes *gs.PartialResourceList    `json:"frontend_prefixes,omitempty"`
+	BackendPrefixes  *gs.PartialResourceList    `json:"backend_prefixes,omitempty"`
+	Replicas         *int                       `json:"replicas,omitempty"`
+}

pkg/apis/lbaas/v2/lb_node_genclient.go

@@ -0,0 +1,24 @@
+package v2
+
+import (
+	"context"
+	"go.anx.io/go-anxcloud/pkg/apis/common/gs"
+	"net/url"
+)
+
+// FilterAPIRequestBody adds the CommonRequestBody
+func (n *Node) FilterAPIRequestBody(ctx context.Context) (interface{}, error) {
+	return gs.RequestBody(ctx, func() interface{} {
+		return &struct {
+			commonRequestBody
+			Node
+		}{
+			Node: *n,
+		}
+	})
+}
+
+// EndpointURL returns the common URL for operations on the Node resource
+func (n *Node) EndpointURL(ctx context.Context) (*url.URL, error) {
+	return gs.EndpointURL(ctx, n, "/api/LBaaSv2/v1/nodes.json")
+}

pkg/apis/lbaas/v2/lb_node_types.go

@@ -0,0 +1,19 @@
+package v2
+
+import (
+	"go.anx.io/go-anxcloud/pkg/apis/common"
+	"go.anx.io/go-anxcloud/pkg/apis/common/gs"
+)
+
+// anxcloud:object
+
+// Node holds the information of a load balancing node within a Cluster
+type Node struct {
+	gs.GenericService
+	gs.HasState
+
+	Identifier string                  `json:"identifier,omitempty" anxcloud:"identifier"`
+	Name       string                  `json:"name,omitempty"`
+	VM         *common.PartialResource `json:"vm,omitempty"`
+	Cluster    *common.PartialResource `json:"cluster,omitempty" anxcloud:"filterable"`
+}

pkg/apis/lbaas/v2/load_balancer_genclient.go

@@ -0,0 +1,24 @@
+package v2
+
+import (
+	"context"
+	"go.anx.io/go-anxcloud/pkg/apis/common/gs"
+	"net/url"
+)
+
+// FilterAPIRequestBody adds the CommonRequestBody
+func (lb *LoadBalancer) FilterAPIRequestBody(ctx context.Context) (interface{}, error) {
+	return gs.RequestBody(ctx, func() interface{} {
+		return &struct {
+			commonRequestBody
+			LoadBalancer
+		}{
+			LoadBalancer: *lb,
+		}
+	})
+}
+
+// EndpointURL returns the common URL for operations on LoadBalancer resource
+func (lb *LoadBalancer) EndpointURL(ctx context.Context) (*url.URL, error) {
+	return gs.EndpointURL(ctx, lb, "/api/LBaaSv2/v1/load_balancers.json")
+}

pkg/apis/lbaas/v2/load_balancer_types.go

@@ -0,0 +1,120 @@
+package v2
+
+import (
+	"encoding/json"
+
+	"go.anx.io/go-anxcloud/pkg/apis/common"
+	"go.anx.io/go-anxcloud/pkg/apis/common/gs"
+)
+
+// anxcloud:object
+
+// LoadBalancer holds the information of a load balancing configuration within a Cluster
+type LoadBalancer struct {
+	gs.GenericService
+	gs.HasState
+
+	Identifier      string                  `json:"identifier,omitempty" anxcloud:"identifier"`
+	Name            string                  `json:"name,omitempty"`
+	Generation      int                     `json:"generation,omitempty"`
+	Cluster         *common.PartialResource `json:"cluster,omitempty" anxcloud:"filterable"`
+	FrontendIPs     *gs.PartialResourceList `json:"frontend_ips,omitempty"`
+	SSLCertificates *gs.PartialResourceList `json:"ssl_certificates,omitempty"`
+	// Definition onfigures the load balancer's frontends and backends.
+	// This field is currently unstable and requires an update of go-anxcloud
+	// in the near future.
+	Definition *Definition `json:"definition,omitempty"`
+}
+
+type FrontendProtocol string
+
+const (
+	FrontendProtocolTCP FrontendProtocol = "TCP"
+)
+
+type BackendProtocol string
+
+const (
+	BackendProtocolTCP   BackendProtocol = "TCP"
+	BackendProtocolPROXY BackendProtocol = "PROXY"
+)
+
+type definition struct {
+	Frontends []Frontend `json:"frontends,omitempty"`
+	Backends  []Backend  `json:"backends,omitempty"`
+}
+
+type Definition definition
+
+func (d *Definition) MarshalJSON() ([]byte, error) {
+	inner := definition(*d)
+
+	data, err := json.Marshal(&inner)
+	if err != nil {
+		return nil, err
+	}
+
+	return json.Marshal(string(data))
+}
+
+func (d *Definition) UnmarshalJSON(data []byte) error {
+	var innerString string
+	if err := json.Unmarshal(data, &innerString); err != nil {
+		return err
+	}
+
+	var inner definition
+	if err := json.Unmarshal([]byte(innerString), &inner); err != nil {
+		return err
+	}
+
+	*d = Definition(inner)
+
+	return nil
+}
+
+// Define ports and protocols exposed to the public side of the Load Balancer
+type Frontend struct {
+	// Name of the Frontend
+	Name string `json:"name"`
+	// Frontend service protocol
+	Protocol FrontendProtocol `json:"protocol"`
+	// Configure frontend - backend relation
+	Backend FrontendBackend `json:"backend,omitempty"`
+	// TCP specific frontend configuration
+	TCP *FrontendTCP `json:"tcp,omitempty"`
+}
+
+// TCP specific frontend configuration
+type FrontendTCP struct {
+	// Port for the frontend to listen to
+	Port uint16 `json:"port,omitempty"`
+}
+
+// Configure frontend - backend relation
+type FrontendBackend struct {
+	// Backend service protocol
+	Protocol BackendProtocol `json:"protocol"`
+	// TCP specific backend configuration
+	TCP *FrontendBackendTCP `json:"tcp,omitempty"`
+}
+
+// TCP specific backend configuration
+type FrontendBackendTCP struct {
+	Port uint16 `json:"port"`
+}
+
+// Define backend services and connect them to frontends
+type Backend struct {
+	// Name of the Backend
+	Name string `json:"name"`
+	// IP addresses of the backend service
+	IPs []string `json:"ips,omitempty"`
+	// List of frontends connected to the backend
+	Frontends []BackendFrontend `json:"frontends,omitempty"`
+}
+
+type BackendFrontend struct {
+	// Name of the frontend to be connected to the backend
+	Name string `json:"name"`
+}