Add support for Targets (kevholditch#35)

onematchfox · kevholditch · commit 2860059c0d7a · 2019-02-04T20:05:22.000Z
* Implemented support for targets Implemented methods listed under https://docs.konghq.com/1.0.x/admin-api/#target-object barring List All Targets * go-imports * Upgrade Kong to 1.0.1 * Fix "DNS issues" on health status test Replace foo.com:443 with www.example.com:80 Extended interval and number of checks before status change to stop kong interfering in simple test case * Kong 1.0.2 * Give Kong time to create balancer and healthchecks * Not just random sleep Slight improvement on test "hack". Sleep until we see that Kong reports that healthchecks are on for a target before we test the ability to mark the target as healthy/unhealthy * Target health test Check for DNS_ERROR as well as HEALTHCHECKS_OFF when waiting Adjust to use overload with ids when setting health * Commented test Sadly had to resort to this... Left existing code there, perhaps someone else feels like figuring out a way to test this in a more robust manner. * go-imports
diff --git a/.travis.yml b/.travis.yml
@@ -7,4 +7,4 @@ services:
   - docker
 env:
   matrix:
-    - KONG_VERSION=1.0.0
+    - KONG_VERSION=1.0.2
diff --git a/README.md b/README.md
@@ -593,6 +593,45 @@ updateUpstreamRequest := &gokong.UpstreamRequest{
 updatedUpstream, err := gokong.NewClient(gokong.NewDefaultConfig()).Upstreams().UpdateByName("test-upstream", updateUpstreamRequest)
 ```
 
+## Targets
+Create a target for an upstream ([for more information on the Target Fields see the Kong documentation](https://getkong.org/docs/0.13.x/admin-api/#upstream-objects)):
+```go
+targetRequest := &TargetRequest{
+  Target:				"foo.com:443",
+  Weight:				100,
+}
+createdTarget, err := gokong.NewClient(gokong.NewDefaultConfig()).Targets().CreateFromUpstreamId("upstreamId", targetRequest)
+```
+
+List all targets for an upstream
+```go
+targets, err := gokong.NewClient(gokong.NewDefaultConfig()).Targets().GetTargetsFromUpstreamId("upstreamId")
+```
+
+Delete a target from an upstream
+```go
+targets, err := gokong.NewClient(gokong.NewDefaultConfig()).Targets().DeleteFromUpstreamById("upstreamId")
+```
+
+Set target as healthy
+```go
+targets, err := gokong.NewClient(gokong.NewDefaultConfig()).Targets().SetTargetFromUpstreamByIdAsHealthy("upstreamId")
+```
+
+Set target as unhealthy
+```go
+targets, err := gokong.NewClient(gokong.NewDefaultConfig()).Targets().SetTargetFromUpstreamByIdAsUnhealthy("upstreamId")
+```
+
+List all targets for an upstream (including health status)
+```go
+targets, err := gokong.NewClient(gokong.NewDefaultConfig()).Targets().GetTargetsWithHealthFromUpstreamName(upstreamId)
+```
+
+**Notes**: Target methods listed above are overloaded in the same fashion as other objects exposed by this library. For parameters:
+ - upstream - either name of id can be used
+ - target - either id or target name (host:port) can be used
+
 # Contributing
 I would love to get contributions to the project so please feel free to submit a PR.  To setup your dev station you need go and docker installed.
 
diff --git a/client.go b/client.go
@@ -137,3 +137,9 @@ func (kongAdminClient *KongAdminClient) Services() *ServiceClient {
 		config: kongAdminClient.config,
 	}
 }
+
+func (kongAdminClient *KongAdminClient) Targets() *TargetClient {
+	return &TargetClient{
+		config: kongAdminClient.config,
+	}
+}
diff --git a/client_test.go b/client_test.go
@@ -14,7 +14,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-const defaultKongVersion = "1.0.0"
+const defaultKongVersion = "1.0.2"
 const kong401Server = "KONG_401_SERVER"
 
 func Test_Newclient(t *testing.T) {
diff --git a/targets.go b/targets.go
@@ -0,0 +1,202 @@
+package gokong
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type TargetClient struct {
+	config *Config
+}
+
+type TargetRequest struct {
+	Target string `json:"target"`
+	Weight int    `json:"weight"`
+}
+
+type Target struct {
+	Id        *string  `json:"id,omitempty"`
+	CreatedAt *float32 `json:"created_at"`
+	Target    *string  `json:"target"`
+	Weight    *int     `json:"weight"`
+	Upstream  *Id      `json:"upstream"`
+	Health    *string  `json:"health"`
+}
+
+type Targets struct {
+	Data   []*Target `json:"data"`
+	Total  int       `json:"total,omitempty"`
+	Next   string    `json:"next,omitempty"`
+	NodeId string    `json:"node_id,omitempty"`
+}
+
+const TargetsPath = "/upstreams/%s/targets"
+
+func (targetClient *TargetClient) CreateFromUpstreamName(name string, targetRequest *TargetRequest) (*Target, error) {
+	return targetClient.CreateFromUpstreamId(name, targetRequest)
+}
+
+func (targetClient *TargetClient) CreateFromUpstreamId(id string, targetRequest *TargetRequest) (*Target, error) {
+	r, body, errs := newPost(targetClient.config, targetClient.config.HostAddress+fmt.Sprintf(TargetsPath, id)).Send(targetRequest).End()
+	if errs != nil {
+		return nil, fmt.Errorf("could not register the target, error: %v", errs)
+	}
+
+	if r.StatusCode == 401 || r.StatusCode == 403 {
+		return nil, fmt.Errorf("not authorised, message from kong: %s", body)
+	}
+
+	createdTarget := &Target{}
+	err := json.Unmarshal([]byte(body), createdTarget)
+	if err != nil {
+		return nil, fmt.Errorf("could not parse target get response, error: %v", err)
+	}
+
+	if createdTarget.Id == nil {
+		return nil, fmt.Errorf("could not register the target, error: %v", body)
+	}
+
+	return createdTarget, nil
+}
+
+func (targetClient *TargetClient) GetTargetsFromUpstreamName(name string) ([]*Target, error) {
+	return targetClient.GetTargetsFromUpstreamId(name)
+}
+
+func (targetClient *TargetClient) GetTargetsFromUpstreamId(id string) ([]*Target, error) {
+	targets := []*Target{}
+	data := &Targets{}
+
+	for {
+		r, body, errs := newGet(targetClient.config, targetClient.config.HostAddress+fmt.Sprintf(TargetsPath, id)).End()
+		if errs != nil {
+			return nil, fmt.Errorf("could not get targets, error: %v", errs)
+		}
+
+		if r.StatusCode == 401 || r.StatusCode == 403 {
+			return nil, fmt.Errorf("not authorised, message from kong: %s", body)
+		}
+
+		if r.StatusCode == 404 {
+			return nil, fmt.Errorf("non existent upstream: %s", id)
+		}
+
+		err := json.Unmarshal([]byte(body), data)
+		if err != nil {
+			return nil, fmt.Errorf("could not parse target get response, error: %v", err)
+		}
+
+		targets = append(targets, data.Data...)
+
+		if data.Next == "" {
+			break
+		}
+	}
+	return targets, nil
+}
+
+func (targetClient *TargetClient) DeleteFromUpstreamByHostPort(upstreamNameOrId string, hostPort string) error {
+	return targetClient.DeleteFromUpstreamById(upstreamNameOrId, hostPort)
+}
+
+func (targetClient *TargetClient) DeleteFromUpstreamById(upstreamNameOrId string, id string) error {
+	r, body, errs := newDelete(targetClient.config, targetClient.config.HostAddress+fmt.Sprintf(TargetsPath, upstreamNameOrId)+fmt.Sprintf("/%s", id)).End()
+	if errs != nil {
+		return fmt.Errorf("could not delete the target, result: %v error: %v", r, errs)
+	}
+
+	if r.StatusCode == 401 || r.StatusCode == 403 {
+		return fmt.Errorf("not authorised, message from kong: %s", body)
+	}
+
+	if r.StatusCode != 204 {
+		return fmt.Errorf("Received unexpected response status code: %d. Body: %s", r.StatusCode, body)
+	}
+
+	return nil
+}
+
+func (targetClient *TargetClient) SetTargetFromUpstreamByHostPortAsHealthy(upstreamNameOrId string, hostPort string) error {
+	return targetClient.SetTargetFromUpstreamByIdAsHealthy(upstreamNameOrId, hostPort)
+}
+
+func (targetClient *TargetClient) SetTargetFromUpstreamByIdAsHealthy(upstreamNameOrId string, id string) error {
+	r, body, errs := newPost(targetClient.config, targetClient.config.HostAddress+fmt.Sprintf(TargetsPath, upstreamNameOrId)+fmt.Sprintf("/%s/healthy", id)).Send("").End()
+	if errs != nil {
+		return fmt.Errorf("could not set the target as healthy, result: %v error: %v", r, errs)
+	}
+
+	if r.StatusCode == 401 || r.StatusCode == 403 {
+		return fmt.Errorf("not authorised, message from kong: %s", body)
+	}
+
+	if r.StatusCode != 204 {
+		return fmt.Errorf("Received unexpected response status code: %d. Body: %s", r.StatusCode, body)
+	}
+
+	return nil
+}
+
+func (targetClient *TargetClient) SetTargetFromUpstreamByHostPortAsUnhealthy(upstreamNameOrId string, hostPort string) error {
+	return targetClient.SetTargetFromUpstreamByIdAsUnhealthy(upstreamNameOrId, hostPort)
+}
+
+func (targetClient *TargetClient) SetTargetFromUpstreamByIdAsUnhealthy(upstreamNameOrId string, id string) error {
+	r, body, errs := newPost(targetClient.config, targetClient.config.HostAddress+fmt.Sprintf(TargetsPath, upstreamNameOrId)+fmt.Sprintf("/%s/unhealthy", id)).Send("").End()
+	if errs != nil {
+		return fmt.Errorf("could not set the target as unhealthy, result: %v error: %v", r, errs)
+	}
+
+	if r.StatusCode == 401 || r.StatusCode == 403 {
+		return fmt.Errorf("not authorised, message from kong: %s", body)
+	}
+
+	if r.StatusCode != 204 {
+		return fmt.Errorf("Received unexpected response status code: %d. Body: %s", r.StatusCode, body)
+	}
+
+	return nil
+}
+
+func (targetClient *TargetClient) GetTargetsWithHealthFromUpstreamName(name string) ([]*Target, error) {
+	return targetClient.GetTargetsWithHealthFromUpstreamId(name)
+}
+
+func (targetClient *TargetClient) GetTargetsWithHealthFromUpstreamId(id string) ([]*Target, error) {
+	targets := []*Target{}
+	data := &Targets{}
+
+	for {
+		r, body, errs := newGet(targetClient.config, targetClient.config.HostAddress+fmt.Sprintf("/upstreams/%s/health", id)).End()
+		if errs != nil {
+			return nil, fmt.Errorf("could not get targets, error: %v", errs)
+		}
+
+		if r.StatusCode == 401 || r.StatusCode == 403 {
+			return nil, fmt.Errorf("not authorised, message from kong: %s", body)
+		}
+
+		if r.StatusCode == 404 {
+			return nil, fmt.Errorf("non existent upstream: %s", id)
+		}
+
+		err := json.Unmarshal([]byte(body), data)
+		if err != nil {
+			return nil, fmt.Errorf("could not parse target get response, error: %v", err)
+		}
+
+		targets = append(targets, data.Data...)
+
+		if data.Next == "" {
+			break
+		}
+	}
+	return targets, nil
+}
+
+// TODO: Implement List all Targets - https://docs.konghq.com/1.0.x/admin-api/#list-all-targets
+// Note: JSON returned by this method has slightly different structure to the standard Get request. This method retruns "upstream_id": "07131005-ba30-4204-a29f-0927d53257b4" instead of "upstream": {"id":"127dfc88-ed57-45bf-b77a-a9d3a152ad31"},
+
+// TODO: Implement other methods available by /targets paths
+// https://docs.konghq.com/1.0.x/admin-api/#update-or-create-upstream
+// https://docs.konghq.com/1.0.x/admin-api/#delete-upstream
diff --git a/targets_test.go b/targets_test.go

Original file line number	Diff line number	Diff line change
`@@ -137,3 +137,9 @@ func (kongAdminClient KongAdminClient) Services() ServiceClient {`
`137`	`137`	`config: kongAdminClient.config,`
`138`	`138`	`}`
`139`	`139`	`}`
	`140`	`+`
	`141`	`+func (kongAdminClient KongAdminClient) Targets() TargetClient {`
	`142`	`+ return &TargetClient{`
	`143`	`+ config: kongAdminClient.config,`
	`144`	`+ }`
	`145`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ import (`
`14`	`14`	`"github.com/stretchr/testify/assert"`
`15`	`15`	`)`
`16`	`16`
`17`		`-const defaultKongVersion = "1.0.0"`
	`17`	`+const defaultKongVersion = "1.0.2"`
`18`	`18`	`const kong401Server = "KONG_401_SERVER"`
`19`	`19`
`20`	`20`	`func Test_Newclient(t *testing.T) {`