Expose Kong capabilities through a function in the client

kong/kong.go

@@ -8,6 +8,7 @@ import (
 	"net/http/httputil"
 	"net/url"
 	"os"
+	"path"
 
 	"github.com/pkg/errors"
 
@@ -31,6 +32,7 @@ var (
 type Client struct {
 	client                  *http.Client
 	baseURL                 string
+	workspace               string
 	common                  service
 	Consumers               AbstractConsumerService
 	Developers              AbstractDeveloperService
@@ -85,7 +87,7 @@ type Status struct {
 }
 
 // NewClient returns a Client which talks to Admin API of Kong
-func NewClient(baseURL *string, client *http.Client) (*Client, error) {
+func NewClient(baseURL *string, workspace string, client *http.Client) (*Client, error) {
 	if client == nil {
 		client = http.DefaultClient
 	}
@@ -101,6 +103,11 @@ func NewClient(baseURL *string, client *http.Client) (*Client, error) {
 	if err != nil {
 		return nil, errors.Wrap(err, "parsing URL")
 	}
+	kong.workspace = workspace
+	if kong.hasWorkspace() {
+		url.Path = path.Join(url.Path, kong.workspace)
+	}
+
 	kong.baseURL = url.String()
 
 	kong.common.client = kong
@@ -147,6 +154,10 @@ func NewClient(baseURL *string, client *http.Client) (*Client, error) {
 	return kong, nil
 }
 
+func (c *Client) hasWorkspace() bool {
+	return len(c.workspace) > 0
+}
+
 // Do executes a HTTP request and returns a response
 func (c *Client) Do(ctx context.Context, req *http.Request,
 	v interface{}) (*Response, error) {
@@ -264,9 +275,13 @@ func (c *Client) Status(ctx context.Context) (*Status, error) {
 }
 
 // Root returns the response of GET request on root of
-// Admin API (GET /).
+// Admin API (GET / by default or GET /kong when the client has workspace defined)
 func (c *Client) Root(ctx context.Context) (map[string]interface{}, error) {
-	req, err := c.NewRequest("GET", "/", nil, nil)
+	queryPath := "/"
+	if c.hasWorkspace() {
+		queryPath = queryPath + "kong"
+	}
+	req, err := c.NewRequest("GET", queryPath, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -278,3 +293,11 @@ func (c *Client) Root(ctx context.Context) (map[string]interface{}, error) {
 	}
 	return root, nil
 }
+
+func (c *Client) Kong(ctx context.Context) (*Kong, error) {
+	root, err := c.Root(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return getKong(root)
+}

kong/kong_test.go

@@ -199,9 +199,9 @@ func NewTestClient(baseURL *string, client *http.Client) (*Client, error) {
 			},
 			rt: defaultTransport,
 		}
-		return NewClient(baseURL, c)
+		return NewClient(baseURL, "", c)
 	}
-	return NewClient(baseURL, client)
+	return NewClient(baseURL, "", client)
 }
 
 type TestWorkspace struct {

kong/types.go

@@ -5,6 +5,16 @@ import (
 	"strings"
 )
 
+type Kong struct {
+	Version     string
+	Enterprise  bool
+	Database    string
+	Credentials struct {
+		hasTagSupport bool
+		minVersion    string
+	}
+}
+
 // Service represents a Service in Kong.
 // Read https://getkong.org/docs/0.13.x/admin-api/#Service-object
 // +k8s:deepcopy-gen=true

kong/utils.go

@@ -2,8 +2,17 @@ package kong
 
 import (
 	"bytes"
+	"fmt"
 	"net/http"
+	"regexp"
 	"strings"
+
+	"github.com/blang/semver/v4"
+)
+
+var (
+	versionParts   = 4
+	kong140Version = semver.MustParse("1.4.0")
 )
 
 // String returns pointer to s.
@@ -91,3 +100,38 @@ func HTTPClientWithHeaders(client *http.Client,
 	}
 	return res
 }
+
+func cleanSemVer(v string) (semver.Version, error) {
+	// fix enterprise edition semver adding patch number
+	// fix enterprise edition version with dash
+	// fix bad version formats like 0.13.0preview1
+	re := regexp.MustCompile(`(\d+\.\d+)(?:[\.-](\d+))?(?:\-?(.+)$|$)`)
+	m := re.FindStringSubmatch(v)
+	if len(m) != versionParts {
+		return semver.Version{}, fmt.Errorf("Unknown Kong version : '%v'", v)
+	}
+	if m[2] == "" {
+		m[2] = "0"
+	}
+	if m[3] != "" {
+		m[3] = "-" + strings.Replace(m[3], "enterprise-edition", "enterprise", 1)
+		m[3] = strings.Replace(m[3], ".", "", -1)
+	}
+	v = fmt.Sprintf("%s.%s%s", m[1], m[2], m[3])
+	return semver.Make(v)
+}
+
+func getKong(root map[string]interface{}) (*Kong, error) {
+	version := root["version"].(string)
+	semVer, err := cleanSemVer(version)
+	if err != nil {
+		return nil, err
+	}
+	kong := new(Kong)
+	kong.Version = semVer.String()
+	kong.Enterprise = strings.Contains(version, "enterprise")
+	kong.Database = root["configuration"].(map[string]interface{})["database"].(string)
+	kong.Credentials.minVersion = kong140Version.String()
+	kong.Credentials.hasTagSupport = semVer.GTE(kong140Version)
+	return kong, nil
+}

kong/utils_test.go

@@ -1,9 +1,9 @@
 package kong
 
 import (
-	"testing"
-
 	"github.com/stretchr/testify/assert"
+	"reflect"
+	"testing"
 )
 
 func TestStringArrayToString(t *testing.T) {
@@ -52,3 +52,91 @@ func TestStringSlice(t *testing.T) {
 	assert.Equal("foo", *arrp[0])
 	assert.Equal("bar", *arrp[1])
 }
+
+func TestFixVersion(t *testing.T) {
+	validVersions := map[string]string{
+		"0.14.1":                          "0.14.1",
+		"0.14.2rc":                        "0.14.2-rc",
+		"0.14.2rc1":                       "0.14.2-rc1",
+		"0.14.2preview":                   "0.14.2-preview",
+		"0.14.2preview1":                  "0.14.2-preview1",
+		"0.33-enterprise-edition":         "0.33.0-enterprise",
+		"0.33-1-enterprise-edition":       "0.33.1-enterprise",
+		"1.3.0.0-enterprise-edition-lite": "1.3.0-0-enterprise-lite",
+		"1.3.0.0-enterprise-lite":         "1.3.0-0-enterprise-lite",
+	}
+	for inputVersion, expectedVersion := range validVersions {
+		v, err := cleanSemVer(inputVersion)
+		if err != nil {
+			t.Errorf("error converting %s: %v", inputVersion, err)
+		} else if v.String() != expectedVersion {
+			t.Errorf("converting %s, expecting %s, getting %s", inputVersion, expectedVersion, v.String())
+		}
+	}
+
+	invalidVersions := []string{
+		"",
+		"0-1-1",
+	}
+	for _, inputVersion := range invalidVersions {
+		_, err := cleanSemVer(inputVersion)
+		if err == nil {
+			t.Errorf("expecting error converting %s, getting no errors", inputVersion)
+		}
+	}
+}
+
+func Test_getKong(t *testing.T) {
+
+	kongWithoutCredentialsSupport := new(Kong)
+	kongWithoutCredentialsSupport.Credentials.minVersion = "1.4.0"
+	kongWithoutCredentialsSupport.Credentials.hasTagSupport = false
+
+	kongWithCredentialsSupport := new(Kong)
+	kongWithCredentialsSupport.Credentials.minVersion = "1.4.0"
+	kongWithCredentialsSupport.Credentials.hasTagSupport = true
+
+	tests := []struct {
+		name     string
+		root     map[string]interface{}
+		expected *Kong
+	}{
+		{
+			root: map[string]interface{}{
+				"version": "0.33-1-enterprise-edition",
+				"configuration": map[string]interface{}{
+					"database": "off",
+				},
+			},
+			expected: &Kong{
+				Version:     "0.33.1-enterprise",
+				Enterprise:  true,
+				Database:    "off",
+				Credentials: kongWithoutCredentialsSupport.Credentials,
+			},
+		},
+		{
+			root: map[string]interface{}{
+				"version": "2.3.2.0",
+				"configuration": map[string]interface{}{
+					"database": "cassandra",
+				},
+			},
+			expected: &Kong{
+				Version:     "2.3.2-0",
+				Enterprise:  false,
+				Database:    "cassandra",
+				Credentials: kongWithCredentialsSupport.Credentials,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, _ := getKong(tt.root)
+			if !reflect.DeepEqual(result, tt.expected) {
+				t.Errorf("Expected %v, but is %v", tt.expected, result)
+			}
+		})
+	}
+
+}