From be51da44bf9de72f8a20d94a45726e2a0a0f0ceb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Fri, 23 Aug 2019 12:11:03 -0400 Subject: [PATCH 01/11] Rename some identifiers to pass go-lint --- client/client.go | 64 ++++++++++++++++++------------------- client/client_test.go | 16 +++++----- cmd/configList.go | 4 +-- cmd/endpointGroupInspect.go | 4 +-- cmd/endpointGroupList.go | 4 +-- cmd/endpointInspect.go | 4 +-- cmd/endpointList.go | 4 +-- cmd/stackDeploy.go | 8 ++--- cmd/stackInspect.go | 10 +++--- cmd/stackList.go | 12 +++---- cmd/stackRemove.go | 10 +++--- cmd/status.go | 4 +-- common/client.go | 8 ++--- common/utils.go | 12 +++---- 14 files changed, 82 insertions(+), 82 deletions(-) diff --git a/client/client.go b/client/client.go index 9d16569..8d3686d 100644 --- a/client/client.go +++ b/client/client.go @@ -14,12 +14,12 @@ import ( ) type StackListFilter struct { - SwarmId string `json:",omitempty"` - EndpointId portainer.EndpointID `json:",omitempty"` + SwarmID string `json:"SwarmId,omitempty"` + EndpointID portainer.EndpointID `json:"EndpointId,omitempty"` } type Config struct { - Url *url.URL + URL *url.URL User string Password string Token string @@ -38,25 +38,25 @@ type PortainerClient interface { GetEndpointGroups() ([]portainer.EndpointGroup, error) // Get stacks, optionally filtered by swarmId and endpointId - GetStacks(swarmId string, endpointId portainer.EndpointID) ([]portainer.Stack, error) + GetStacks(swarmID string, endpointID portainer.EndpointID) ([]portainer.Stack, error) // Create swarm stack - CreateSwarmStack(stackName string, environmentVariables []portainer.Pair, stackFileContent string, swarmClusterId string, endpointId portainer.EndpointID) (stack portainer.Stack, err error) + CreateSwarmStack(stackName string, environmentVariables []portainer.Pair, stackFileContent string, swarmClusterID string, endpointID portainer.EndpointID) (stack portainer.Stack, err error) // Create compose stack - CreateComposeStack(stackName string, environmentVariables []portainer.Pair, stackFileContent string, endpointId portainer.EndpointID) (stack portainer.Stack, err error) + CreateComposeStack(stackName string, environmentVariables []portainer.Pair, stackFileContent string, endpointID portainer.EndpointID) (stack portainer.Stack, err error) // Update stack - UpdateStack(stack portainer.Stack, environmentVariables []portainer.Pair, stackFileContent string, prune bool, endpointId portainer.EndpointID) error + UpdateStack(stack portainer.Stack, environmentVariables []portainer.Pair, stackFileContent string, prune bool, endpointID portainer.EndpointID) error // Delete stack - DeleteStack(stackId portainer.StackID) error + DeleteStack(stackID portainer.StackID) error // Get stack file content - GetStackFileContent(stackId portainer.StackID) (content string, err error) + GetStackFileContent(stackID portainer.StackID) (content string, err error) // Get endpoint Docker info - GetEndpointDockerInfo(endpointId portainer.EndpointID) (info map[string]interface{}, err error) + GetEndpointDockerInfo(endpointID portainer.EndpointID) (info map[string]interface{}, err error) // Get Portainer status info GetStatus() (portainer.Status, error) @@ -103,12 +103,12 @@ func checkResponseForErrors(resp *http.Response) error { // Do an http request func (n *portainerClientImp) do(uri, method string, request io.Reader, requestType string, headers http.Header) (resp *http.Response, err error) { - requestUrl, err := n.url.Parse(uri) + requestURL, err := n.url.Parse(uri) if err != nil { return } - req, err := http.NewRequest(method, requestUrl.String(), request) + req, err := http.NewRequest(method, requestURL.String(), request) if err != nil { return } @@ -230,62 +230,62 @@ func (n *portainerClientImp) GetEndpointGroups() (endpointGroups []portainer.End return } -func (n *portainerClientImp) GetStacks(swarmId string, endpointId portainer.EndpointID) (stacks []portainer.Stack, err error) { +func (n *portainerClientImp) GetStacks(swarmID string, endpointID portainer.EndpointID) (stacks []portainer.Stack, err error) { filter := StackListFilter{ - SwarmId: swarmId, - EndpointId: endpointId, + SwarmID: swarmID, + EndpointID: endpointID, } - filterJsonBytes, _ := json.Marshal(filter) - filterJsonString := string(filterJsonBytes) + filterJSONBytes, _ := json.Marshal(filter) + filterJSONString := string(filterJSONBytes) - err = n.doJSON(fmt.Sprintf("stacks?filters=%s", filterJsonString), http.MethodGet, nil, &stacks) + err = n.doJSON(fmt.Sprintf("stacks?filters=%s", filterJSONString), http.MethodGet, nil, &stacks) return } -func (n *portainerClientImp) CreateSwarmStack(stackName string, environmentVariables []portainer.Pair, stackFileContent string, swarmClusterId string, endpointId portainer.EndpointID) (stack portainer.Stack, err error) { +func (n *portainerClientImp) CreateSwarmStack(stackName string, environmentVariables []portainer.Pair, stackFileContent string, swarmClusterID string, endpointID portainer.EndpointID) (stack portainer.Stack, err error) { reqBody := StackCreateRequest{ Name: stackName, Env: environmentVariables, - SwarmID: swarmClusterId, + SwarmID: swarmClusterID, StackFileContent: stackFileContent, } - err = n.doJSON(fmt.Sprintf("stacks?type=%v&method=%s&endpointId=%v", 1, "string", endpointId), http.MethodPost, &reqBody, &stack) + err = n.doJSON(fmt.Sprintf("stacks?type=%v&method=%s&endpointId=%v", 1, "string", endpointID), http.MethodPost, &reqBody, &stack) return } -func (n *portainerClientImp) CreateComposeStack(stackName string, environmentVariables []portainer.Pair, stackFileContent string, endpointId portainer.EndpointID) (stack portainer.Stack, err error) { +func (n *portainerClientImp) CreateComposeStack(stackName string, environmentVariables []portainer.Pair, stackFileContent string, endpointID portainer.EndpointID) (stack portainer.Stack, err error) { reqBody := StackCreateRequest{ Name: stackName, Env: environmentVariables, StackFileContent: stackFileContent, } - err = n.doJSON(fmt.Sprintf("stacks?type=%v&method=%s&endpointId=%v", 2, "string", endpointId), http.MethodPost, &reqBody, &stack) + err = n.doJSON(fmt.Sprintf("stacks?type=%v&method=%s&endpointId=%v", 2, "string", endpointID), http.MethodPost, &reqBody, &stack) return } -func (n *portainerClientImp) UpdateStack(stack portainer.Stack, environmentVariables []portainer.Pair, stackFileContent string, prune bool, endpointId portainer.EndpointID) (err error) { +func (n *portainerClientImp) UpdateStack(stack portainer.Stack, environmentVariables []portainer.Pair, stackFileContent string, prune bool, endpointID portainer.EndpointID) (err error) { reqBody := StackUpdateRequest{ Env: environmentVariables, StackFileContent: stackFileContent, Prune: prune, } - err = n.doJSON(fmt.Sprintf("stacks/%v?endpointId=%v", stack.ID, endpointId), http.MethodPut, &reqBody, nil) + err = n.doJSON(fmt.Sprintf("stacks/%v?endpointId=%v", stack.ID, endpointID), http.MethodPut, &reqBody, nil) return } -func (n *portainerClientImp) DeleteStack(stackId portainer.StackID) (err error) { - err = n.doJSON(fmt.Sprintf("stacks/%d", stackId), http.MethodDelete, nil, nil) +func (n *portainerClientImp) DeleteStack(stackID portainer.StackID) (err error) { + err = n.doJSON(fmt.Sprintf("stacks/%d", stackID), http.MethodDelete, nil, nil) return } -func (n *portainerClientImp) GetStackFileContent(stackId portainer.StackID) (content string, err error) { +func (n *portainerClientImp) GetStackFileContent(stackID portainer.StackID) (content string, err error) { var respBody StackFileInspectResponse - err = n.doJSON(fmt.Sprintf("stacks/%v/file", stackId), http.MethodGet, nil, &respBody) + err = n.doJSON(fmt.Sprintf("stacks/%v/file", stackID), http.MethodGet, nil, &respBody) if err != nil { return } @@ -295,8 +295,8 @@ func (n *portainerClientImp) GetStackFileContent(stackId portainer.StackID) (con return } -func (n *portainerClientImp) GetEndpointDockerInfo(endpointId portainer.EndpointID) (info map[string]interface{}, err error) { - err = n.doJSON(fmt.Sprintf("endpoints/%v/docker/info", endpointId), http.MethodGet, nil, &info) +func (n *portainerClientImp) GetEndpointDockerInfo(endpointID portainer.EndpointID) (info map[string]interface{}, err error) { + err = n.doJSON(fmt.Sprintf("endpoints/%v/docker/info", endpointID), http.MethodGet, nil, &info) return } @@ -309,7 +309,7 @@ func (n *portainerClientImp) GetStatus() (status portainer.Status, err error) { func NewClient(httpClient *http.Client, config Config) PortainerClient { return &portainerClientImp{ httpClient: httpClient, - url: config.Url, + url: config.URL, user: config.User, password: config.Password, token: config.Token, diff --git a/client/client_test.go b/client/client_test.go index d752efa..41576c6 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -12,24 +12,24 @@ import ( "github.com/stretchr/testify/assert" ) -func readRequestBodyAsJson(req *http.Request, body *map[string]interface{}) (err error) { +func readRequestBodyAsJSON(req *http.Request, body *map[string]interface{}) (err error) { bodyBytes, err := ioutil.ReadAll(req.Body) defer req.Body.Close() err = json.Unmarshal(bodyBytes, body) return } -func writeResponseBodyAsJson(w http.ResponseWriter, body map[string]interface{}) (err error) { +func writeResponseBodyAsJSON(w http.ResponseWriter, body map[string]interface{}) (err error) { bodyBytes, err := json.Marshal(body) fmt.Fprintln(w, string(bodyBytes)) return } func TestNewClient(t *testing.T) { - apiUrl, _ := url.Parse("http://validurl.com/api") + apiURL, _ := url.Parse("http://validurl.com/api") validClient := NewClient(http.DefaultClient, Config{ - Url: apiUrl, + URL: apiURL, }) assert.NotNil(t, validClient) } @@ -37,7 +37,7 @@ func TestNewClient(t *testing.T) { func TestClientAuthenticates(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { var body map[string]interface{} - err := readRequestBodyAsJson(req, &body) + err := readRequestBodyAsJSON(req, &body) assert.Equal(t, req.Method, http.MethodPost) assert.Equal(t, req.RequestURI, "/api/auth") @@ -53,16 +53,16 @@ func TestClientAuthenticates(t *testing.T) { assert.NotNil(t, body["Password"]) assert.Equal(t, body["Password"], "a") - writeResponseBodyAsJson(w, map[string]interface{}{ + writeResponseBodyAsJSON(w, map[string]interface{}{ "jwt": "somerandomtoken", }) })) defer ts.Close() - apiUrl, _ := url.Parse(ts.URL + "/api/") + apiURL, _ := url.Parse(ts.URL + "/api/") customClient := NewClient(ts.Client(), Config{ - Url: apiUrl, + URL: apiURL, User: "admin", Password: "a", UserAgent: "GE007", diff --git a/cmd/configList.go b/cmd/configList.go index 5c76e20..2942758 100644 --- a/cmd/configList.go +++ b/cmd/configList.go @@ -77,9 +77,9 @@ var configListCmd = &cobra.Command{ common.CheckError(flushErr) case "json": // Print configs in a json format - statusJsonBytes, err := json.Marshal(configs) + statusJSONBytes, err := json.Marshal(configs) common.CheckError(err) - fmt.Println(string(statusJsonBytes)) + fmt.Println(string(statusJSONBytes)) default: // Print configs in a custom format template, templateParsingErr := template.New("configTpl").Parse(viper.GetString("config.list.format")) diff --git a/cmd/endpointGroupInspect.go b/cmd/endpointGroupInspect.go index 606b47a..cc3a1ba 100644 --- a/cmd/endpointGroupInspect.go +++ b/cmd/endpointGroupInspect.go @@ -44,9 +44,9 @@ var endpointGroupInspectCmd = &cobra.Command{ common.CheckError(err) case "json": // Print endpoint group in a json format - endpointJsonBytes, err := json.Marshal(endpointGroup) + endpointJSONBytes, err := json.Marshal(endpointGroup) common.CheckError(err) - fmt.Println(string(endpointJsonBytes)) + fmt.Println(string(endpointJSONBytes)) default: // Print endpoint group in a custom format template, err := template.New("endpointGroupTpl").Parse(viper.GetString("endpoint.group.inspect.format")) diff --git a/cmd/endpointGroupList.go b/cmd/endpointGroupList.go index 5722d8f..b3f094d 100644 --- a/cmd/endpointGroupList.go +++ b/cmd/endpointGroupList.go @@ -55,9 +55,9 @@ var endpointGroupListCmd = &cobra.Command{ common.CheckError(flushErr) case "json": // Print endpoint groups in a json format - statusJsonBytes, err := json.Marshal(endpointGroups) + statusJSONBytes, err := json.Marshal(endpointGroups) common.CheckError(err) - fmt.Println(string(statusJsonBytes)) + fmt.Println(string(statusJSONBytes)) default: // Print endpoint groups in a custom format template, templateParsingErr := template.New("endpointGroupTpl").Parse(viper.GetString("endpoint.group.list.format")) diff --git a/cmd/endpointInspect.go b/cmd/endpointInspect.go index cdce6b4..1fb98eb 100644 --- a/cmd/endpointInspect.go +++ b/cmd/endpointInspect.go @@ -74,9 +74,9 @@ var endpointInspectCmd = &cobra.Command{ common.CheckError(err) case "json": // Print endpoint in a json format - endpointJsonBytes, err := json.Marshal(endpoint) + endpointJSONBytes, err := json.Marshal(endpoint) common.CheckError(err) - fmt.Println(string(endpointJsonBytes)) + fmt.Println(string(endpointJSONBytes)) default: // Print endpoint in a custom format template, err := template.New("endpointTpl").Parse(viper.GetString("endpoint.inspect.format")) diff --git a/cmd/endpointList.go b/cmd/endpointList.go index ac23979..df6f27f 100644 --- a/cmd/endpointList.go +++ b/cmd/endpointList.go @@ -71,9 +71,9 @@ var endpointListCmd = &cobra.Command{ common.CheckError(flushErr) case "json": // Print endpoints in a json format - statusJsonBytes, err := json.Marshal(endpoints) + statusJSONBytes, err := json.Marshal(endpoints) common.CheckError(err) - fmt.Println(string(statusJsonBytes)) + fmt.Println(string(statusJSONBytes)) default: // Print endpoints in a custom format template, templateParsingErr := template.New("endpointTpl").Parse(viper.GetString("endpoint.list.format")) diff --git a/cmd/stackDeploy.go b/cmd/stackDeploy.go index be43275..b8059cd 100644 --- a/cmd/stackDeploy.go +++ b/cmd/stackDeploy.go @@ -56,7 +56,7 @@ var stackDeployCmd = &cobra.Command{ logrus.WithFields(logrus.Fields{ "endpoint": endpoint.Name, }).Debug("Getting endpoint's Docker info") - endpointSwarmClusterId, selectionErr := common.GetEndpointSwarmClusterId(endpoint.ID) + endpointSwarmClusterID, selectionErr := common.GetEndpointSwarmClusterID(endpoint.ID) if selectionErr == nil { // It's a swarm cluster } else if selectionErr == common.ErrStackClusterNotFound { @@ -70,7 +70,7 @@ var stackDeployCmd = &cobra.Command{ "stack": stackName, "endpoint": endpoint.Name, }).Debug("Getting stack") - retrievedStack, stackRetrievalErr := common.GetStackByName(stackName, endpointSwarmClusterId, endpoint.ID) + retrievedStack, stackRetrievalErr := common.GetStackByName(stackName, endpointSwarmClusterID, endpoint.ID) if stackRetrievalErr == nil { // We are updating an existing stack logrus.WithFields(logrus.Fields{ @@ -129,13 +129,13 @@ var stackDeployCmd = &cobra.Command{ stackFileContent, loadingErr := loadStackFile(viper.GetString("stack.deploy.stack-file")) common.CheckError(loadingErr) - if endpointSwarmClusterId != "" { + if endpointSwarmClusterID != "" { // It's a swarm cluster logrus.WithFields(logrus.Fields{ "stack": stackName, "endpoint": endpoint.Name, }).Info("Creating stack") - stack, deploymentErr := portainerClient.CreateSwarmStack(stackName, loadedEnvironmentVariables, stackFileContent, endpointSwarmClusterId, endpoint.ID) + stack, deploymentErr := portainerClient.CreateSwarmStack(stackName, loadedEnvironmentVariables, stackFileContent, endpointSwarmClusterID, endpoint.ID) common.CheckError(deploymentErr) logrus.WithFields(logrus.Fields{ "stack": stack.Name, diff --git a/cmd/stackInspect.go b/cmd/stackInspect.go index ff52aa9..5bdd1eb 100644 --- a/cmd/stackInspect.go +++ b/cmd/stackInspect.go @@ -24,7 +24,7 @@ var stackInspectCmd = &cobra.Command{ Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { stackName := args[0] - var endpointSwarmClusterId string + var endpointSwarmClusterID string var stack portainer.Stack var endpoint portainer.Endpoint @@ -51,14 +51,14 @@ var stackInspectCmd = &cobra.Command{ "endpoint": endpoint.Name, }).Debug("Getting endpoint's Docker info") var selectionErr, stackRetrievalErr error - endpointSwarmClusterId, selectionErr = common.GetEndpointSwarmClusterId(endpoint.ID) + endpointSwarmClusterID, selectionErr = common.GetEndpointSwarmClusterID(endpoint.ID) if selectionErr == nil { // It's a swarm cluster logrus.WithFields(logrus.Fields{ "stack": stackName, "endpoint": endpoint.Name, }).Debug("Getting stack") - stack, stackRetrievalErr = common.GetStackByName(stackName, endpointSwarmClusterId, endpoint.ID) + stack, stackRetrievalErr = common.GetStackByName(stackName, endpointSwarmClusterID, endpoint.ID) } else if selectionErr == common.ErrStackClusterNotFound { // It's not a swarm cluster logrus.WithFields(logrus.Fields{ @@ -95,9 +95,9 @@ var stackInspectCmd = &cobra.Command{ common.CheckError(flushErr) case "json": // Print stack in a json format - stackJsonBytes, err := json.Marshal(stack) + stackJSONBytes, err := json.Marshal(stack) common.CheckError(err) - fmt.Println(string(stackJsonBytes)) + fmt.Println(string(stackJSONBytes)) default: // Print stack in a custom format template, templateParsingErr := template.New("stackTpl").Parse(viper.GetString("stack.inspect.format")) diff --git a/cmd/stackList.go b/cmd/stackList.go index 06bff27..2e8b735 100644 --- a/cmd/stackList.go +++ b/cmd/stackList.go @@ -36,7 +36,7 @@ var stackListCmd = &cobra.Command{ endpoints, endpointsRetrievalErr := portainerClient.GetEndpoints() common.CheckError(endpointsRetrievalErr) - var endpointSwarmClusterId string + var endpointSwarmClusterID string var stacks []portainer.Stack if endpointName := viper.GetString("stack.list.endpoint"); endpointName != "" { // Get endpoint by name @@ -47,13 +47,13 @@ var stackListCmd = &cobra.Command{ "endpoint": endpoint.Name, }).Debug("Getting endpoint's Docker info") var selectionErr error - endpointSwarmClusterId, selectionErr = common.GetEndpointSwarmClusterId(endpoint.ID) + endpointSwarmClusterID, selectionErr = common.GetEndpointSwarmClusterID(endpoint.ID) if selectionErr == nil { // It's a swarm cluster logrus.WithFields(logrus.Fields{ "endpoint": endpoint.Name, }).Debug("Getting stacks") - stacks, err = portainerClient.GetStacks(endpointSwarmClusterId, endpoint.ID) + stacks, err = portainerClient.GetStacks(endpointSwarmClusterID, endpoint.ID) common.CheckError(err) } else if selectionErr == common.ErrStackClusterNotFound { // It's not a swarm cluster @@ -83,7 +83,7 @@ var stackListCmd = &cobra.Command{ }) common.CheckError(err) for _, s := range stacks { - stackEndpoint, err := common.GetEndpointFromListById(endpoints, s.EndpointID) + stackEndpoint, err := common.GetEndpointFromListByID(endpoints, s.EndpointID) common.CheckError(err) _, err = fmt.Fprintln(writer, fmt.Sprintf( "%v\t%s\t%v\t%s", @@ -98,9 +98,9 @@ var stackListCmd = &cobra.Command{ common.CheckError(flushErr) case "json": // Print stacks in a json format - stacksJsonBytes, err := json.Marshal(stacks) + stacksJSONBytes, err := json.Marshal(stacks) common.CheckError(err) - fmt.Println(string(stacksJsonBytes)) + fmt.Println(string(stacksJSONBytes)) default: // Print stacks in a custom format template, templateParsingErr := template.New("stackTpl").Parse(viper.GetString("stack.list.format")) diff --git a/cmd/stackRemove.go b/cmd/stackRemove.go index 30160cf..0e147d5 100644 --- a/cmd/stackRemove.go +++ b/cmd/stackRemove.go @@ -22,7 +22,7 @@ var stackRemoveCmd = &cobra.Command{ common.CheckError(clientRetrievalErr) stackName := args[0] - var endpointSwarmClusterId string + var endpointSwarmClusterID string var stack portainer.Stack var endpoint portainer.Endpoint @@ -49,14 +49,14 @@ var stackRemoveCmd = &cobra.Command{ "endpoint": endpoint.Name, }).Debug("Getting endpoint's Docker info") var selectionErr, stackRetrievalErr error - endpointSwarmClusterId, selectionErr = common.GetEndpointSwarmClusterId(endpoint.ID) + endpointSwarmClusterID, selectionErr = common.GetEndpointSwarmClusterID(endpoint.ID) if selectionErr == nil { // It's a swarm cluster logrus.WithFields(logrus.Fields{ "stack": stackName, "endpoint": endpoint.Name, }).Debug("Getting stack") - stack, stackRetrievalErr = common.GetStackByName(stackName, endpointSwarmClusterId, endpoint.ID) + stack, stackRetrievalErr = common.GetStackByName(stackName, endpointSwarmClusterID, endpoint.ID) } else if selectionErr == common.ErrStackClusterNotFound { // It's not a swarm cluster logrus.WithFields(logrus.Fields{ @@ -71,13 +71,13 @@ var stackRemoveCmd = &cobra.Command{ if stackRetrievalErr == nil { // The stack exists - stackId := stack.ID + stackID := stack.ID logrus.WithFields(logrus.Fields{ "stack": stackName, "endpoint": endpoint.Name, }).Info("Removing stack") - err := portainerClient.DeleteStack(stackId) + err := portainerClient.DeleteStack(stackID) common.CheckError(err) logrus.WithFields(logrus.Fields{ "stack": stack.Name, diff --git a/cmd/status.go b/cmd/status.go index 3534a6c..7602a8c 100644 --- a/cmd/status.go +++ b/cmd/status.go @@ -53,9 +53,9 @@ var statusCmd = &cobra.Command{ common.CheckError(flushErr) case "json": // Print status in a json format - statusJsonBytes, err := json.Marshal(respBody) + statusJSONBytes, err := json.Marshal(respBody) common.CheckError(err) - fmt.Println(string(statusJsonBytes)) + fmt.Println(string(statusJSONBytes)) default: // Print status in a custom format template, templateParsingErr := template.New("statusTpl").Parse(viper.GetString("status.format")) diff --git a/common/client.go b/common/client.go index 742d3f9..c8114f1 100644 --- a/common/client.go +++ b/common/client.go @@ -36,7 +36,7 @@ func GetDefaultClient() (c client.PortainerClient, err error) { return } - c = client.NewClient(GetDefaultHttpClient(), config) + c = client.NewClient(GetDefaultHTTPClient(), config) c.BeforeRequest(func(req *http.Request) (err error) { var bodyString string @@ -84,13 +84,13 @@ func GetDefaultClient() (c client.PortainerClient, err error) { // Get the default config for a client func GetDefaultClientConfig() (config client.Config, err error) { - apiUrl, err := url.Parse(strings.TrimRight(viper.GetString("url"), "/") + "/api/") + apiURL, err := url.Parse(strings.TrimRight(viper.GetString("url"), "/") + "/api/") if err != nil { return } config = client.Config{ - Url: apiUrl, + URL: apiURL, User: viper.GetString("user"), Password: viper.GetString("password"), Token: viper.GetString("auth-token"), @@ -102,7 +102,7 @@ func GetDefaultClientConfig() (config client.Config, err error) { } // Get the default http client for a Portainer client -func GetDefaultHttpClient() *http.Client { +func GetDefaultHTTPClient() *http.Client { return &http.Client{ Timeout: viper.GetDuration("timeout"), Transport: &http.Transport{ diff --git a/common/utils.go b/common/utils.go index 5d13171..a4f2705 100644 --- a/common/utils.go +++ b/common/utils.go @@ -53,13 +53,13 @@ func GetDefaultEndpoint() (endpoint portainer.Endpoint, err error) { return } -func GetStackByName(name string, swarmId string, endpointId portainer.EndpointID) (stack portainer.Stack, err error) { +func GetStackByName(name string, swarmID string, endpointID portainer.EndpointID) (stack portainer.Stack, err error) { portainerClient, err := GetClient() if err != nil { return } - stacks, err := portainerClient.GetStacks(swarmId, endpointId) + stacks, err := portainerClient.GetStacks(swarmID, endpointID) if err != nil { return } @@ -113,7 +113,7 @@ func GetEndpointGroupByName(name string) (endpointGroup portainer.EndpointGroup, return } -func GetEndpointFromListById(endpoints []portainer.Endpoint, id portainer.EndpointID) (endpoint portainer.Endpoint, err error) { +func GetEndpointFromListByID(endpoints []portainer.Endpoint, id portainer.EndpointID) (endpoint portainer.Endpoint, err error) { for i := range endpoints { if endpoints[i].ID == id { return endpoints[i], err @@ -131,14 +131,14 @@ func GetEndpointFromListByName(endpoints []portainer.Endpoint, name string) (end return endpoint, ErrEndpointNotFound } -func GetEndpointSwarmClusterId(endpointId portainer.EndpointID) (endpointSwarmClusterId string, err error) { +func GetEndpointSwarmClusterID(endpointID portainer.EndpointID) (endpointSwarmClusterID string, err error) { // Get docker information for endpoint portainerClient, err := GetClient() if err != nil { return } - result, err := portainerClient.GetEndpointDockerInfo(endpointId) + result, err := portainerClient.GetEndpointDockerInfo(endpointID) if err != nil { return } @@ -146,7 +146,7 @@ func GetEndpointSwarmClusterId(endpointId portainer.EndpointID) (endpointSwarmCl // Get swarm (if any) information for endpoint id, selectionErr := selectValue(result, []string{"Swarm", "Cluster", "ID"}) if selectionErr == nil { - endpointSwarmClusterId = id.(string) + endpointSwarmClusterID = id.(string) } else if selectionErr == valueNotFoundError { err = ErrStackClusterNotFound } else { From 161fc48b5ae4760c9b3bd72c0efd57b611533e8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Fri, 23 Aug 2019 13:08:08 -0400 Subject: [PATCH 02/11] Add comments to exported types to pass go-lint --- client/client.go | 5 ++++- client/portainerTypes.go | 7 +++++++ common/client.go | 8 ++++---- common/configs.go | 2 ++ common/printing.go | 1 + common/utils.go | 14 ++++++++++++++ version/version.go | 3 +++ 7 files changed, 35 insertions(+), 5 deletions(-) diff --git a/client/client.go b/client/client.go index 8d3686d..f0f81ff 100644 --- a/client/client.go +++ b/client/client.go @@ -13,11 +13,13 @@ import ( portainer "github.com/portainer/portainer/api" ) +// StackListFilter represents a filter for a stack list type StackListFilter struct { SwarmID string `json:"SwarmId,omitempty"` EndpointID portainer.EndpointID `json:"EndpointId,omitempty"` } +// Config represents a Portainer client configuration type Config struct { URL *url.URL User string @@ -27,6 +29,7 @@ type Config struct { DoNotUseToken bool } +// PortainerClient represents a Portainer API client type PortainerClient interface { // Authenticate a user to get an auth token Authenticate() (token string, err error) @@ -305,7 +308,7 @@ func (n *portainerClientImp) GetStatus() (status portainer.Status, err error) { return } -// Create a new client +// NewClient creates a new Portainer API client func NewClient(httpClient *http.Client, config Config) PortainerClient { return &portainerClientImp{ httpClient: httpClient, diff --git a/client/portainerTypes.go b/client/portainerTypes.go index 68f2f15..359a29f 100644 --- a/client/portainerTypes.go +++ b/client/portainerTypes.go @@ -6,6 +6,7 @@ import ( portainer "github.com/portainer/portainer/api" ) +// GetTranslatedStackType returns a stack's Type field (int) translated to it's human readable form (string) func GetTranslatedStackType(s portainer.Stack) string { switch s.Type { case 1: @@ -17,6 +18,7 @@ func GetTranslatedStackType(s portainer.Stack) string { } } +// StackCreateRequest represents the body of a request to POST /stacks type StackCreateRequest struct { Name string SwarmID string @@ -24,16 +26,19 @@ type StackCreateRequest struct { Env []portainer.Pair `json:",omitempty"` } +// StackUpdateRequest represents the body of a request to PUT /stacks/{id} type StackUpdateRequest struct { StackFileContent string Env []portainer.Pair `json:",omitempty"` Prune bool } +// StackFileInspectResponse represents the body of a response for a request to GET /stack/{id}/file type StackFileInspectResponse struct { StackFileContent string } +// GenericError represents the body of a generic error returned by the Portainer API type GenericError struct { Err string Details string @@ -47,11 +52,13 @@ func (e *GenericError) Error() string { } } +// AuthenticateUserRequest represents the body of a request to POST /auth type AuthenticateUserRequest struct { Username string Password string } +// AuthenticateUserResponse represents the body of a response for a request to POST /auth type AuthenticateUserResponse struct { Jwt string } diff --git a/common/client.go b/common/client.go index c8114f1..57baef3 100644 --- a/common/client.go +++ b/common/client.go @@ -18,7 +18,7 @@ import ( var cachedClient client.PortainerClient -// Get the cached client or a new one +// GetClient returns the cached Portainer API client. If none is present, creates and returns a new one). func GetClient() (c client.PortainerClient, err error) { if cachedClient == nil { cachedClient, err = GetDefaultClient() @@ -29,7 +29,7 @@ func GetClient() (c client.PortainerClient, err error) { return cachedClient, nil } -// Get the default client +// GetDefaultClient returns a new Portainer API client with the default configuration func GetDefaultClient() (c client.PortainerClient, err error) { config, err := GetDefaultClientConfig() if err != nil { @@ -82,7 +82,7 @@ func GetDefaultClient() (c client.PortainerClient, err error) { return } -// Get the default config for a client +// GetDefaultClientConfig returns the default configuration for a Portainer API client func GetDefaultClientConfig() (config client.Config, err error) { apiURL, err := url.Parse(strings.TrimRight(viper.GetString("url"), "/") + "/api/") if err != nil { @@ -101,7 +101,7 @@ func GetDefaultClientConfig() (config client.Config, err error) { return } -// Get the default http client for a Portainer client +// GetDefaultHTTPClient returns the default HTTP client for a Portainer API client func GetDefaultHTTPClient() *http.Client { return &http.Client{ Timeout: viper.GetDuration("timeout"), diff --git a/common/configs.go b/common/configs.go index 59a2348..0c18842 100644 --- a/common/configs.go +++ b/common/configs.go @@ -8,6 +8,7 @@ import ( "github.com/spf13/viper" ) +// LoadCofig loads the configuration file currently used by viper into a new viper instance func LoadCofig() (v *viper.Viper, err error) { // Set config file name var configFile string @@ -34,6 +35,7 @@ func LoadCofig() (v *viper.Viper, err error) { return } +// CheckConfigKeyExists checks a given configuration key exists in the default viper func CheckConfigKeyExists(key string) (keyExists bool) { for _, k := range viper.AllKeys() { if k == key { diff --git a/common/printing.go b/common/printing.go index 218d210..cfe163b 100644 --- a/common/printing.go +++ b/common/printing.go @@ -7,6 +7,7 @@ import ( "text/tabwriter" ) +// NewTabWriter returns a new tabwriter.Writer func NewTabWriter(headers []string) (*tabwriter.Writer, error) { writer := tabwriter.NewWriter(os.Stdout, 20, 2, 3, ' ', 0) _, err := fmt.Fprintln(writer, strings.Join(headers, "\t")) diff --git a/common/utils.go b/common/utils.go index a4f2705..f9ce174 100644 --- a/common/utils.go +++ b/common/utils.go @@ -8,6 +8,7 @@ import ( "github.com/sirupsen/logrus" ) +// Common errors const ( ErrStackNotFound = Error("Stack not found") ErrStackClusterNotFound = Error("Stack cluster not found") @@ -29,6 +30,7 @@ func (e Error) Error() string { return string(e) } +// GetDefaultEndpoint returns the default endpoint (if only one endpoint exists) func GetDefaultEndpoint() (endpoint portainer.Endpoint, err error) { portainerClient, err := GetClient() if err != nil { @@ -53,6 +55,8 @@ func GetDefaultEndpoint() (endpoint portainer.Endpoint, err error) { return } +// GetStackByName returns a stack by its name from the (endpoint filtered) list +// of all stacks func GetStackByName(name string, swarmID string, endpointID portainer.EndpointID) (stack portainer.Stack, err error) { portainerClient, err := GetClient() if err != nil { @@ -73,6 +77,8 @@ func GetStackByName(name string, swarmID string, endpointID portainer.EndpointID return } +// GetEndpointByName returns an endpoint by its name from the list of all +// endpoints func GetEndpointByName(name string) (endpoint portainer.Endpoint, err error) { portainerClient, err := GetClient() if err != nil { @@ -93,6 +99,8 @@ func GetEndpointByName(name string) (endpoint portainer.Endpoint, err error) { return } +// GetEndpointGroupByName returns an endpoint group by its name from the list +// of all endpoint groups func GetEndpointGroupByName(name string) (endpointGroup portainer.EndpointGroup, err error) { portainerClient, err := GetClient() if err != nil { @@ -113,6 +121,8 @@ func GetEndpointGroupByName(name string) (endpointGroup portainer.EndpointGroup, return } +// GetEndpointFromListByID returns an endpoint by its id from a list of +// endpoints func GetEndpointFromListByID(endpoints []portainer.Endpoint, id portainer.EndpointID) (endpoint portainer.Endpoint, err error) { for i := range endpoints { if endpoints[i].ID == id { @@ -122,6 +132,8 @@ func GetEndpointFromListByID(endpoints []portainer.Endpoint, id portainer.Endpoi return endpoint, ErrEndpointNotFound } +// GetEndpointFromListByName returns an endpoint by its name from a list of +// endpoints func GetEndpointFromListByName(endpoints []portainer.Endpoint, name string) (endpoint portainer.Endpoint, err error) { for i := range endpoints { if endpoints[i].Name == name { @@ -131,6 +143,7 @@ func GetEndpointFromListByName(endpoints []portainer.Endpoint, name string) (end return endpoint, ErrEndpointNotFound } +// GetEndpointSwarmClusterID returns an endpoint's swarm cluster id func GetEndpointSwarmClusterID(endpointID portainer.EndpointID) (endpointSwarmClusterID string, err error) { // Get docker information for endpoint portainerClient, err := GetClient() @@ -167,6 +180,7 @@ func selectValue(jsonMap map[string]interface{}, jsonPath []string) (interface{} } } +// GetFormatHelp returns the help string for --format flags func GetFormatHelp(v interface{}) (r string) { typeOfV := reflect.TypeOf(v) r = fmt.Sprintf(` diff --git a/version/version.go b/version/version.go index 734f199..3308067 100644 --- a/version/version.go +++ b/version/version.go @@ -19,6 +19,7 @@ var ( buildDate string ) +// BuildVersionString returns the tool's version func BuildVersionString() string { osArch := runtime.GOOS + "/" + runtime.GOARCH @@ -33,6 +34,8 @@ func BuildVersionString() string { return fmt.Sprintf("%s %s %s BuildDate: %s", programName, version, osArch, buildDate) } +// BuildUseAgentString returns the tool's User-Agent in requests to the +// Portainer API func BuildUseAgentString() string { var theVersion = version if theVersion == "" { From 3194260c05e9579e00f331e88b3c27ef5b299afc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Fri, 23 Aug 2019 13:14:49 -0400 Subject: [PATCH 03/11] Remove else statement with single return sentence --- client/portainerTypes.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/client/portainerTypes.go b/client/portainerTypes.go index 359a29f..0e421b5 100644 --- a/client/portainerTypes.go +++ b/client/portainerTypes.go @@ -47,9 +47,8 @@ type GenericError struct { func (e *GenericError) Error() string { if e.Details != "" { return fmt.Sprintf("%s: %s", e.Err, e.Details) - } else { - return fmt.Sprintf("%s", e.Err) } + return fmt.Sprintf("%s", e.Err) } // AuthenticateUserRequest represents the body of a request to POST /auth From c0cc50c81ad9186f260409dc75b9dea5fccd7258 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Fri, 23 Aug 2019 13:55:30 -0400 Subject: [PATCH 04/11] Add unit test for client/portainerTypes.go --- client/portainerTypes_test.go | 101 ++++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 client/portainerTypes_test.go diff --git a/client/portainerTypes_test.go b/client/portainerTypes_test.go new file mode 100644 index 0000000..e9adf01 --- /dev/null +++ b/client/portainerTypes_test.go @@ -0,0 +1,101 @@ +package client + +import ( + "testing" + + portainer "github.com/portainer/portainer/api" + "github.com/stretchr/testify/assert" +) + +func TestGetTranslatedStackType(t *testing.T) { + type args struct { + s portainer.Stack + } + tests := []struct { + name string + args args + want string + }{ + { + name: "swarm stack type", + args: args{ + s: portainer.Stack{ + Type: 1, + }, + }, + want: "swarm", + }, + { + name: "compose stack type", + args: args{ + s: portainer.Stack{ + Type: 2, + }, + }, + want: "compose", + }, + { + name: "unknown stack type", + args: args{ + s: portainer.Stack{ + Type: 100, + }, + }, + want: "", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.want, GetTranslatedStackType(tt.args.s)) + }) + } +} + +func TestGenericError_Error(t *testing.T) { + type fields struct { + Err string + Details string + } + tests := []struct { + name string + fields fields + want string + }{ + { + name: "error with message and details", + fields: fields{ + Err: "error", + Details: "details", + }, + want: "error: details", + }, + { + name: "error with message and no details", + fields: fields{ + Err: "error", + }, + want: "error", + }, + { + name: "error with no error message and details", + fields: fields{ + Details: "details", + }, + want: ": details", + }, + { + name: "error with no error message and no details", + fields: fields{}, + want: "", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + e := &GenericError{ + Err: tt.fields.Err, + Details: tt.fields.Details, + } + assert.Equal(t, tt.want, e.Error()) + }) + } +} From f82f116e1bce4ca7641eb06c7be5823f47f827f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Fri, 23 Aug 2019 14:07:06 -0400 Subject: [PATCH 05/11] Change GetTranslatedStackType to use StackType instead of Stack --- client/portainerTypes.go | 8 ++++---- client/portainerTypes_test.go | 16 +++++----------- cmd/stackInspect.go | 2 +- cmd/stackList.go | 2 +- 4 files changed, 11 insertions(+), 17 deletions(-) diff --git a/client/portainerTypes.go b/client/portainerTypes.go index 0e421b5..48d9d9a 100644 --- a/client/portainerTypes.go +++ b/client/portainerTypes.go @@ -7,11 +7,11 @@ import ( ) // GetTranslatedStackType returns a stack's Type field (int) translated to it's human readable form (string) -func GetTranslatedStackType(s portainer.Stack) string { - switch s.Type { - case 1: +func GetTranslatedStackType(t portainer.StackType) string { + switch t { + case portainer.DockerSwarmStack: return "swarm" - case 2: + case portainer.DockerComposeStack: return "compose" default: return "" diff --git a/client/portainerTypes_test.go b/client/portainerTypes_test.go index e9adf01..eb7050e 100644 --- a/client/portainerTypes_test.go +++ b/client/portainerTypes_test.go @@ -9,7 +9,7 @@ import ( func TestGetTranslatedStackType(t *testing.T) { type args struct { - s portainer.Stack + t portainer.StackType } tests := []struct { name string @@ -19,34 +19,28 @@ func TestGetTranslatedStackType(t *testing.T) { { name: "swarm stack type", args: args{ - s: portainer.Stack{ - Type: 1, - }, + t: portainer.DockerSwarmStack, }, want: "swarm", }, { name: "compose stack type", args: args{ - s: portainer.Stack{ - Type: 2, - }, + t: portainer.DockerComposeStack, }, want: "compose", }, { name: "unknown stack type", args: args{ - s: portainer.Stack{ - Type: 100, - }, + t: 100, }, want: "", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert.Equal(t, tt.want, GetTranslatedStackType(tt.args.s)) + assert.Equal(t, tt.want, GetTranslatedStackType(tt.args.t)) }) } } diff --git a/cmd/stackInspect.go b/cmd/stackInspect.go index 5bdd1eb..829ea01 100644 --- a/cmd/stackInspect.go +++ b/cmd/stackInspect.go @@ -87,7 +87,7 @@ var stackInspectCmd = &cobra.Command{ "%v\t%s\t%v\t%s", stack.ID, stack.Name, - client.GetTranslatedStackType(stack), + client.GetTranslatedStackType(stack.Type), endpoint.Name, )) common.CheckError(err) diff --git a/cmd/stackList.go b/cmd/stackList.go index 2e8b735..d79d237 100644 --- a/cmd/stackList.go +++ b/cmd/stackList.go @@ -89,7 +89,7 @@ var stackListCmd = &cobra.Command{ "%v\t%s\t%v\t%s", s.ID, s.Name, - client.GetTranslatedStackType(s), + client.GetTranslatedStackType(s.Type), stackEndpoint.Name, )) common.CheckError(err) From 2cc0faa62508d807e261948bba8d7c8fa68dbf90 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Sat, 24 Aug 2019 00:39:43 -0400 Subject: [PATCH 06/11] Add unit tests for portainerClientImpl.do() --- client/client_test.go | 135 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 135 insertions(+) diff --git a/client/client_test.go b/client/client_test.go index 41576c6..ca7c980 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -3,6 +3,7 @@ package client import ( "encoding/json" "fmt" + "io" "io/ioutil" "net/http" "net/http/httptest" @@ -71,3 +72,137 @@ func TestClientAuthenticates(t *testing.T) { assert.Nil(t, err) assert.Equal(t, token, "somerandomtoken") } + +func Test_portainerClientImp_do(t *testing.T) { + type fields struct { + user string + password string + token string + userAgent string + doNotUseToken bool + beforeRequestHooks []func(req *http.Request) (err error) + afterResponseHooks []func(resp *http.Response) (err error) + server *httptest.Server + beforeFunctionCall func(t *testing.T, tt *fields) + } + type args struct { + uri string + method string + request io.Reader + requestType string + headers http.Header + } + tests := []struct { + name string + fields fields + args args + wantRespCheck func(resp *http.Response) bool + wantErr bool + }{ + { + name: "error on bad URI", + fields: fields{ + server: httptest.NewUnstartedServer(nil), + }, + args: args{ + uri: string(0x7f), + }, + wantErr: true, + }, + { + name: "error on bad method", + fields: fields{ + server: httptest.NewUnstartedServer(nil), + }, + args: args{ + method: "WOLOLO?", + }, + wantErr: true, + }, + { + name: "extra headers are added", + fields: fields{ + token: "somerandomtoken", + server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + assert.Equal(t, req.Header.Get("Some-Header"), "value") + })), + }, + args: args{ + headers: http.Header{ + "Some-Header": []string{ + "value", + }, + }, + }, + }, + { + name: "Authorization header is added when doNotUseToken is false", + fields: fields{ + token: "token", + server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + assert.NotEmpty(t, req.Header.Get("Authorization")) + })), + }, + }, + { + name: "Authorization header is not added when doNotUseToken is true", + fields: fields{ + doNotUseToken: true, + server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + assert.Equal(t, req.Header.Get("Authorization"), "") + })), + }, + }, + { + name: "returns error on http error", + fields: fields{ + token: "token", + server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {})), + beforeFunctionCall: func(t *testing.T, tt *fields) { + tt.server.Close() + }, + }, + wantErr: true, + }, + { + name: "returns error on response error", + fields: fields{ + token: "token", + server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + w.WriteHeader(http.StatusInternalServerError) + })), + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.fields.server.Start() + defer tt.fields.server.Close() + + apiURL, _ := url.Parse(tt.fields.server.URL + "/api/") + + n := &portainerClientImp{ + httpClient: tt.fields.server.Client(), + url: apiURL, + user: tt.fields.user, + password: tt.fields.password, + token: tt.fields.token, + userAgent: tt.fields.userAgent, + doNotUseToken: tt.fields.doNotUseToken, + beforeRequestHooks: tt.fields.beforeRequestHooks, + afterResponseHooks: tt.fields.afterResponseHooks, + } + + if tt.fields.beforeFunctionCall != nil { + tt.fields.beforeFunctionCall(t, &tt.fields) + } + gotResp, err := n.do(tt.args.uri, tt.args.method, tt.args.request, tt.args.requestType, tt.args.headers) + + assert.Equal(t, tt.wantErr, err != nil) + if tt.wantRespCheck != nil { + assert.True(t, tt.wantRespCheck(gotResp)) + } + }) + } +} From 14043a8bf8bfdb64da68a78457f938c95f42db16 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Sat, 24 Aug 2019 09:01:27 -0400 Subject: [PATCH 07/11] Refactor auth token setting in Portainer client --- client/client.go | 56 +++++++++++++++++++++---------------------- client/client_test.go | 22 ----------------- 2 files changed, 27 insertions(+), 51 deletions(-) diff --git a/client/client.go b/client/client.go index f0f81ff..1ee628d 100644 --- a/client/client.go +++ b/client/client.go @@ -78,7 +78,6 @@ type portainerClientImp struct { password string token string userAgent string - doNotUseToken bool beforeRequestHooks []func(req *http.Request) (err error) afterResponseHooks []func(resp *http.Response) (err error) } @@ -125,16 +124,6 @@ func (n *portainerClientImp) do(uri, method string, request io.Reader, requestTy req.Header.Set("User-Agent", n.userAgent) } - if !n.doNotUseToken { - if n.token == "" { - n.token, err = n.Authenticate() - if err != nil { - return - } - } - req.Header.Set("Authorization", "Bearer "+n.token) - } - // Run all "before request" hooks for i := 0; i < len(n.beforeRequestHooks); i++ { err = n.beforeRequestHooks[i](req) @@ -165,7 +154,7 @@ func (n *portainerClientImp) do(uri, method string, request io.Reader, requestTy } // Do a JSON http request -func (n *portainerClientImp) doJSON(uri, method string, request interface{}, response interface{}) error { +func (n *portainerClientImp) doJSON(uri, method string, headers http.Header, request interface{}, response interface{}) error { var body io.Reader if request != nil { @@ -176,7 +165,7 @@ func (n *portainerClientImp) doJSON(uri, method string, request interface{}, res body = bytes.NewReader(reqBodyBytes) } - resp, err := n.do(uri, method, body, "application/json", nil) + resp, err := n.do(uri, method, body, "application/json", headers) if err != nil { return err } @@ -192,6 +181,20 @@ func (n *portainerClientImp) doJSON(uri, method string, request interface{}, res return nil } +// Do a JSON http request with an auth token +func (n *portainerClientImp) doJSONWithToken(uri, method string, headers http.Header, request interface{}, response interface{}) (err error) { + // Ensure there is an auth token + if n.token == "" { + n.token, err = n.Authenticate() + if err != nil { + return + } + } + headers.Set("Authorization", "Bearer "+n.token) + + return n.doJSON(uri, method, headers, request, response) +} + func (n *portainerClientImp) BeforeRequest(hook func(req *http.Request) (err error)) { n.beforeRequestHooks = append(n.beforeRequestHooks, hook) } @@ -208,28 +211,23 @@ func (n *portainerClientImp) Authenticate() (token string, err error) { respBody := AuthenticateUserResponse{} - previousDoNotUseTokenValue := n.doNotUseToken - n.doNotUseToken = true - - err = n.doJSON("auth", http.MethodPost, &reqBody, &respBody) + err = n.doJSON("auth", http.MethodPost, http.Header{}, &reqBody, &respBody) if err != nil { return } - n.doNotUseToken = previousDoNotUseTokenValue - token = respBody.Jwt return } func (n *portainerClientImp) GetEndpoints() (endpoints []portainer.Endpoint, err error) { - err = n.doJSON("endpoints", http.MethodGet, nil, &endpoints) + err = n.doJSONWithToken("endpoints", http.MethodGet, http.Header{}, nil, &endpoints) return } func (n *portainerClientImp) GetEndpointGroups() (endpointGroups []portainer.EndpointGroup, err error) { - err = n.doJSON("endpoint_groups", http.MethodGet, nil, &endpointGroups) + err = n.doJSONWithToken("endpoint_groups", http.MethodGet, http.Header{}, nil, &endpointGroups) return } @@ -242,7 +240,7 @@ func (n *portainerClientImp) GetStacks(swarmID string, endpointID portainer.Endp filterJSONBytes, _ := json.Marshal(filter) filterJSONString := string(filterJSONBytes) - err = n.doJSON(fmt.Sprintf("stacks?filters=%s", filterJSONString), http.MethodGet, nil, &stacks) + err = n.doJSONWithToken(fmt.Sprintf("stacks?filters=%s", filterJSONString), http.MethodGet, http.Header{}, nil, &stacks) return } @@ -254,7 +252,7 @@ func (n *portainerClientImp) CreateSwarmStack(stackName string, environmentVaria StackFileContent: stackFileContent, } - err = n.doJSON(fmt.Sprintf("stacks?type=%v&method=%s&endpointId=%v", 1, "string", endpointID), http.MethodPost, &reqBody, &stack) + err = n.doJSONWithToken(fmt.Sprintf("stacks?type=%v&method=%s&endpointId=%v", 1, "string", endpointID), http.MethodPost, http.Header{}, &reqBody, &stack) return } @@ -265,7 +263,7 @@ func (n *portainerClientImp) CreateComposeStack(stackName string, environmentVar StackFileContent: stackFileContent, } - err = n.doJSON(fmt.Sprintf("stacks?type=%v&method=%s&endpointId=%v", 2, "string", endpointID), http.MethodPost, &reqBody, &stack) + err = n.doJSONWithToken(fmt.Sprintf("stacks?type=%v&method=%s&endpointId=%v", 2, "string", endpointID), http.MethodPost, http.Header{}, &reqBody, &stack) return } @@ -276,19 +274,19 @@ func (n *portainerClientImp) UpdateStack(stack portainer.Stack, environmentVaria Prune: prune, } - err = n.doJSON(fmt.Sprintf("stacks/%v?endpointId=%v", stack.ID, endpointID), http.MethodPut, &reqBody, nil) + err = n.doJSONWithToken(fmt.Sprintf("stacks/%v?endpointId=%v", stack.ID, endpointID), http.MethodPut, http.Header{}, &reqBody, nil) return } func (n *portainerClientImp) DeleteStack(stackID portainer.StackID) (err error) { - err = n.doJSON(fmt.Sprintf("stacks/%d", stackID), http.MethodDelete, nil, nil) + err = n.doJSONWithToken(fmt.Sprintf("stacks/%d", stackID), http.MethodDelete, http.Header{}, nil, nil) return } func (n *portainerClientImp) GetStackFileContent(stackID portainer.StackID) (content string, err error) { var respBody StackFileInspectResponse - err = n.doJSON(fmt.Sprintf("stacks/%v/file", stackID), http.MethodGet, nil, &respBody) + err = n.doJSONWithToken(fmt.Sprintf("stacks/%v/file", stackID), http.MethodGet, http.Header{}, nil, &respBody) if err != nil { return } @@ -299,12 +297,12 @@ func (n *portainerClientImp) GetStackFileContent(stackID portainer.StackID) (con } func (n *portainerClientImp) GetEndpointDockerInfo(endpointID portainer.EndpointID) (info map[string]interface{}, err error) { - err = n.doJSON(fmt.Sprintf("endpoints/%v/docker/info", endpointID), http.MethodGet, nil, &info) + err = n.doJSONWithToken(fmt.Sprintf("endpoints/%v/docker/info", endpointID), http.MethodGet, http.Header{}, nil, &info) return } func (n *portainerClientImp) GetStatus() (status portainer.Status, err error) { - err = n.doJSON("status", http.MethodGet, nil, &status) + err = n.doJSONWithToken("status", http.MethodGet, http.Header{}, nil, &status) return } diff --git a/client/client_test.go b/client/client_test.go index ca7c980..7ed88d0 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -79,7 +79,6 @@ func Test_portainerClientImp_do(t *testing.T) { password string token string userAgent string - doNotUseToken bool beforeRequestHooks []func(req *http.Request) (err error) afterResponseHooks []func(resp *http.Response) (err error) server *httptest.Server @@ -122,7 +121,6 @@ func Test_portainerClientImp_do(t *testing.T) { { name: "extra headers are added", fields: fields{ - token: "somerandomtoken", server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { assert.Equal(t, req.Header.Get("Some-Header"), "value") })), @@ -135,24 +133,6 @@ func Test_portainerClientImp_do(t *testing.T) { }, }, }, - { - name: "Authorization header is added when doNotUseToken is false", - fields: fields{ - token: "token", - server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { - assert.NotEmpty(t, req.Header.Get("Authorization")) - })), - }, - }, - { - name: "Authorization header is not added when doNotUseToken is true", - fields: fields{ - doNotUseToken: true, - server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { - assert.Equal(t, req.Header.Get("Authorization"), "") - })), - }, - }, { name: "returns error on http error", fields: fields{ @@ -167,7 +147,6 @@ func Test_portainerClientImp_do(t *testing.T) { { name: "returns error on response error", fields: fields{ - token: "token", server: httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { w.WriteHeader(http.StatusInternalServerError) })), @@ -189,7 +168,6 @@ func Test_portainerClientImp_do(t *testing.T) { password: tt.fields.password, token: tt.fields.token, userAgent: tt.fields.userAgent, - doNotUseToken: tt.fields.doNotUseToken, beforeRequestHooks: tt.fields.beforeRequestHooks, afterResponseHooks: tt.fields.afterResponseHooks, } From 19f58c4e1fef9813f6bed7ad2c13de74fc4a418b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Sat, 24 Aug 2019 09:05:34 -0400 Subject: [PATCH 08/11] Move Content-Type header setting to doJSON() in Portainer client --- client/client.go | 7 ++++--- client/client_test.go | 11 +++++------ 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/client/client.go b/client/client.go index 1ee628d..36a458b 100644 --- a/client/client.go +++ b/client/client.go @@ -104,7 +104,7 @@ func checkResponseForErrors(resp *http.Response) error { } // Do an http request -func (n *portainerClientImp) do(uri, method string, request io.Reader, requestType string, headers http.Header) (resp *http.Response, err error) { +func (n *portainerClientImp) do(uri, method string, request io.Reader, headers http.Header) (resp *http.Response, err error) { requestURL, err := n.url.Parse(uri) if err != nil { return @@ -120,7 +120,6 @@ func (n *portainerClientImp) do(uri, method string, request io.Reader, requestTy } if request != nil { - req.Header.Set("Content-Type", requestType) req.Header.Set("User-Agent", n.userAgent) } @@ -165,7 +164,9 @@ func (n *portainerClientImp) doJSON(uri, method string, headers http.Header, req body = bytes.NewReader(reqBodyBytes) } - resp, err := n.do(uri, method, body, "application/json", headers) + headers.Set("Content-Type", "application/json") + + resp, err := n.do(uri, method, body, headers) if err != nil { return err } diff --git a/client/client_test.go b/client/client_test.go index 7ed88d0..e22294f 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -85,11 +85,10 @@ func Test_portainerClientImp_do(t *testing.T) { beforeFunctionCall func(t *testing.T, tt *fields) } type args struct { - uri string - method string - request io.Reader - requestType string - headers http.Header + uri string + method string + request io.Reader + headers http.Header } tests := []struct { name string @@ -175,7 +174,7 @@ func Test_portainerClientImp_do(t *testing.T) { if tt.fields.beforeFunctionCall != nil { tt.fields.beforeFunctionCall(t, &tt.fields) } - gotResp, err := n.do(tt.args.uri, tt.args.method, tt.args.request, tt.args.requestType, tt.args.headers) + gotResp, err := n.do(tt.args.uri, tt.args.method, tt.args.request, tt.args.headers) assert.Equal(t, tt.wantErr, err != nil) if tt.wantRespCheck != nil { From a8bed6a7cc4949e72ecb2800ef3a90e256cdceab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Sat, 24 Aug 2019 15:06:16 -0400 Subject: [PATCH 09/11] Rename request and reponse to requestBody and responseBody --- client/client.go | 16 ++++++++-------- client/client_test.go | 10 +++++----- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/client/client.go b/client/client.go index 36a458b..9f43e6a 100644 --- a/client/client.go +++ b/client/client.go @@ -104,13 +104,13 @@ func checkResponseForErrors(resp *http.Response) error { } // Do an http request -func (n *portainerClientImp) do(uri, method string, request io.Reader, headers http.Header) (resp *http.Response, err error) { +func (n *portainerClientImp) do(uri, method string, requestBody io.Reader, headers http.Header) (resp *http.Response, err error) { requestURL, err := n.url.Parse(uri) if err != nil { return } - req, err := http.NewRequest(method, requestURL.String(), request) + req, err := http.NewRequest(method, requestURL.String(), requestBody) if err != nil { return } @@ -119,7 +119,7 @@ func (n *portainerClientImp) do(uri, method string, request io.Reader, headers h req.Header = headers } - if request != nil { + if requestBody != nil { req.Header.Set("User-Agent", n.userAgent) } @@ -153,11 +153,11 @@ func (n *portainerClientImp) do(uri, method string, request io.Reader, headers h } // Do a JSON http request -func (n *portainerClientImp) doJSON(uri, method string, headers http.Header, request interface{}, response interface{}) error { +func (n *portainerClientImp) doJSON(uri, method string, headers http.Header, requestBody interface{}, responseBody interface{}) error { var body io.Reader - if request != nil { - reqBodyBytes, err := json.Marshal(request) + if requestBody != nil { + reqBodyBytes, err := json.Marshal(requestBody) if err != nil { return err } @@ -171,9 +171,9 @@ func (n *portainerClientImp) doJSON(uri, method string, headers http.Header, req return err } - if response != nil { + if responseBody != nil { d := json.NewDecoder(resp.Body) - err := d.Decode(response) + err := d.Decode(responseBody) if err != nil { return err } diff --git a/client/client_test.go b/client/client_test.go index e22294f..65dd558 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -85,10 +85,10 @@ func Test_portainerClientImp_do(t *testing.T) { beforeFunctionCall func(t *testing.T, tt *fields) } type args struct { - uri string - method string - request io.Reader - headers http.Header + uri string + method string + requestBody io.Reader + headers http.Header } tests := []struct { name string @@ -174,7 +174,7 @@ func Test_portainerClientImp_do(t *testing.T) { if tt.fields.beforeFunctionCall != nil { tt.fields.beforeFunctionCall(t, &tt.fields) } - gotResp, err := n.do(tt.args.uri, tt.args.method, tt.args.request, tt.args.headers) + gotResp, err := n.do(tt.args.uri, tt.args.method, tt.args.requestBody, tt.args.headers) assert.Equal(t, tt.wantErr, err != nil) if tt.wantRespCheck != nil { From 7fb7710c55a0ea164f022f5524f08e777a929c80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Sat, 24 Aug 2019 15:39:56 -0400 Subject: [PATCH 10/11] Remove condition of requestBody being not nil to set user agent --- client/client.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/client/client.go b/client/client.go index 9f43e6a..b89c9c7 100644 --- a/client/client.go +++ b/client/client.go @@ -119,9 +119,8 @@ func (n *portainerClientImp) do(uri, method string, requestBody io.Reader, heade req.Header = headers } - if requestBody != nil { - req.Header.Set("User-Agent", n.userAgent) - } + // Set user agent header + req.Header.Set("User-Agent", n.userAgent) // Run all "before request" hooks for i := 0; i < len(n.beforeRequestHooks); i++ { From 1c3a1c665ebc117b6eceef6d91fb39df95bd0e11 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Carlos=20Mej=C3=ADas=20Rodr=C3=ADguez?= Date: Sat, 24 Aug 2019 16:45:20 -0400 Subject: [PATCH 11/11] Add unit tests for checkResponseForErrors() --- client/client_test.go | 48 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/client/client_test.go b/client/client_test.go index 65dd558..b932259 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -1,6 +1,7 @@ package client import ( + "bytes" "encoding/json" "fmt" "io" @@ -183,3 +184,50 @@ func Test_portainerClientImp_do(t *testing.T) { }) } } + +func Test_checkResponseForErrors(t *testing.T) { + type args struct { + resp *http.Response + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "generic error", + args: args{ + resp: func() (resp *http.Response) { + resp = &http.Response{ + StatusCode: http.StatusNotFound, + } + bodyBytes, _ := json.Marshal(map[string]interface{}{ + "Err": "Error", + "Details": "Not found", + }) + resp.Body = ioutil.NopCloser(bytes.NewReader(bodyBytes)) + return + }(), + }, + wantErr: true, + }, + { + name: "non generic error", + args: args{ + resp: func() (resp *http.Response) { + resp = &http.Response{ + StatusCode: http.StatusNotFound, + Body: ioutil.NopCloser(bytes.NewReader([]byte("Err"))), + } + return + }(), + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.wantErr, checkResponseForErrors(tt.args.resp) != nil) + }) + } +}