Mirrored_Repos/psu
1
0
Fork 0
mirror of https://gitlab.com/psuapp/psu.git synced 2024-08-30 18:12:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename some identifiers to pass go-lint

Browse Source
This commit is contained in:
Juan Carlos Mejías Rodríguez 2019-08-23 12:11:03 -04:00
parent c6b7c2ce25
commit be51da44bf
14 changed files with 82 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
client/client.go
View File

@ -14,12 +14,12 @@ import (
) )
type StackListFilter struct { type StackListFilter struct {
SwarmId string `json:",omitempty"` SwarmID string `json:"SwarmId,omitempty"`
EndpointId portainer.EndpointID `json:",omitempty"` EndpointID portainer.EndpointID `json:"EndpointId,omitempty"`
} }
type Config struct { type Config struct {
Url *url.URL URL *url.URL
User string User string
Password string Password string
Token string Token string
@ -38,25 +38,25 @@ type PortainerClient interface {
GetEndpointGroups() ([]portainer.EndpointGroup, error) GetEndpointGroups() ([]portainer.EndpointGroup, error)
// Get stacks, optionally filtered by swarmId and endpointId // 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 // 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 // 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 // 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 // Delete stack
DeleteStack(stackId portainer.StackID) error DeleteStack(stackID portainer.StackID) error
// Get stack file content // Get stack file content
GetStackFileContent(stackId portainer.StackID) (content string, err error) GetStackFileContent(stackID portainer.StackID) (content string, err error)
// Get endpoint Docker info // 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 // Get Portainer status info
GetStatus() (portainer.Status, error) GetStatus() (portainer.Status, error)
@ -103,12 +103,12 @@ func checkResponseForErrors(resp *http.Response) error {
// Do an http request // 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, 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 { if err != nil {
return return
} }
req, err := http.NewRequest(method, requestUrl.String(), request) req, err := http.NewRequest(method, requestURL.String(), request)
if err != nil { if err != nil {
return return
} }
@ -230,62 +230,62 @@ func (n *portainerClientImp) GetEndpointGroups() (endpointGroups []portainer.End
return 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{ filter := StackListFilter{
SwarmId: swarmId, SwarmID: swarmID,
EndpointId: endpointId, EndpointID: endpointID,
} }
filterJsonBytes, _ := json.Marshal(filter) filterJSONBytes, _ := json.Marshal(filter)
filterJsonString := string(filterJsonBytes) 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 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{ reqBody := StackCreateRequest{
Name: stackName, Name: stackName,
Env: environmentVariables, Env: environmentVariables,
SwarmID: swarmClusterId, SwarmID: swarmClusterID,
StackFileContent: stackFileContent, 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 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{ reqBody := StackCreateRequest{
Name: stackName, Name: stackName,
Env: environmentVariables, Env: environmentVariables,
StackFileContent: stackFileContent, 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 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{ reqBody := StackUpdateRequest{
Env: environmentVariables, Env: environmentVariables,
StackFileContent: stackFileContent, StackFileContent: stackFileContent,
Prune: prune, 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 return
} }
func (n *portainerClientImp) DeleteStack(stackId portainer.StackID) (err error) { func (n *portainerClientImp) DeleteStack(stackID portainer.StackID) (err error) {
err = n.doJSON(fmt.Sprintf("stacks/%d", stackId), http.MethodDelete, nil, nil) err = n.doJSON(fmt.Sprintf("stacks/%d", stackID), http.MethodDelete, nil, nil)
return 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 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 { if err != nil {
return return
} }
@ -295,8 +295,8 @@ func (n *portainerClientImp) GetStackFileContent(stackId portainer.StackID) (con
return return
} }
func (n *portainerClientImp) GetEndpointDockerInfo(endpointId portainer.EndpointID) (info map[string]interface{}, err error) { 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.doJSON(fmt.Sprintf("endpoints/%v/docker/info", endpointID), http.MethodGet, nil, &info)
return return
} }
@ -309,7 +309,7 @@ func (n *portainerClientImp) GetStatus() (status portainer.Status, err error) {
func NewClient(httpClient *http.Client, config Config) PortainerClient { func NewClient(httpClient *http.Client, config Config) PortainerClient {
return &portainerClientImp{ return &portainerClientImp{
httpClient: httpClient, httpClient: httpClient,
url: config.Url, url: config.URL,
user: config.User, user: config.User,
password: config.Password, password: config.Password,
token: config.Token, token: config.Token,

16
client/client_test.go
View File

@ -12,24 +12,24 @@ import (
"github.com/stretchr/testify/assert" "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) bodyBytes, err := ioutil.ReadAll(req.Body)
defer req.Body.Close() defer req.Body.Close()
err = json.Unmarshal(bodyBytes, body) err = json.Unmarshal(bodyBytes, body)
return 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) bodyBytes, err := json.Marshal(body)
fmt.Fprintln(w, string(bodyBytes)) fmt.Fprintln(w, string(bodyBytes))
return return
} }
func TestNewClient(t *testing.T) { func TestNewClient(t *testing.T) {
apiUrl, _ := url.Parse("http://validurl.com/api") apiURL, _ := url.Parse("http://validurl.com/api")
validClient := NewClient(http.DefaultClient, Config{ validClient := NewClient(http.DefaultClient, Config{
Url: apiUrl, URL: apiURL,
}) })
assert.NotNil(t, validClient) assert.NotNil(t, validClient)
} }
@ -37,7 +37,7 @@ func TestNewClient(t *testing.T) {
func TestClientAuthenticates(t *testing.T) { func TestClientAuthenticates(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
var body map[string]interface{} var body map[string]interface{}
err := readRequestBodyAsJson(req, &body) err := readRequestBodyAsJSON(req, &body)
assert.Equal(t, req.Method, http.MethodPost) assert.Equal(t, req.Method, http.MethodPost)
assert.Equal(t, req.RequestURI, "/api/auth") assert.Equal(t, req.RequestURI, "/api/auth")
@ -53,16 +53,16 @@ func TestClientAuthenticates(t *testing.T) {
assert.NotNil(t, body["Password"]) assert.NotNil(t, body["Password"])
assert.Equal(t, body["Password"], "a") assert.Equal(t, body["Password"], "a")
writeResponseBodyAsJson(w, map[string]interface{}{ writeResponseBodyAsJSON(w, map[string]interface{}{
"jwt": "somerandomtoken", "jwt": "somerandomtoken",
}) })
})) }))
defer ts.Close() defer ts.Close()
apiUrl, _ := url.Parse(ts.URL + "/api/") apiURL, _ := url.Parse(ts.URL + "/api/")
customClient := NewClient(ts.Client(), Config{ customClient := NewClient(ts.Client(), Config{
Url: apiUrl, URL: apiURL,
User: "admin", User: "admin",
Password: "a", Password: "a",
UserAgent: "GE007", UserAgent: "GE007",

4
cmd/configList.go
View File

@ -77,9 +77,9 @@ var configListCmd = &cobra.Command{
common.CheckError(flushErr) common.CheckError(flushErr)
case "json": case "json":
// Print configs in a json format // Print configs in a json format
statusJsonBytes, err := json.Marshal(configs) statusJSONBytes, err := json.Marshal(configs)
common.CheckError(err) common.CheckError(err)
fmt.Println(string(statusJsonBytes)) fmt.Println(string(statusJSONBytes))
default: default:
// Print configs in a custom format // Print configs in a custom format
template, templateParsingErr := template.New("configTpl").Parse(viper.GetString("config.list.format")) template, templateParsingErr := template.New("configTpl").Parse(viper.GetString("config.list.format"))

4
cmd/endpointGroupInspect.go
View File

@ -44,9 +44,9 @@ var endpointGroupInspectCmd = &cobra.Command{
common.CheckError(err) common.CheckError(err)
case "json": case "json":
// Print endpoint group in a json format // Print endpoint group in a json format
endpointJsonBytes, err := json.Marshal(endpointGroup) endpointJSONBytes, err := json.Marshal(endpointGroup)
common.CheckError(err) common.CheckError(err)
fmt.Println(string(endpointJsonBytes)) fmt.Println(string(endpointJSONBytes))
default: default:
// Print endpoint group in a custom format // Print endpoint group in a custom format
template, err := template.New("endpointGroupTpl").Parse(viper.GetString("endpoint.group.inspect.format")) template, err := template.New("endpointGroupTpl").Parse(viper.GetString("endpoint.group.inspect.format"))

4
cmd/endpointGroupList.go
View File

@ -55,9 +55,9 @@ var endpointGroupListCmd = &cobra.Command{
common.CheckError(flushErr) common.CheckError(flushErr)
case "json": case "json":
// Print endpoint groups in a json format // Print endpoint groups in a json format
statusJsonBytes, err := json.Marshal(endpointGroups) statusJSONBytes, err := json.Marshal(endpointGroups)
common.CheckError(err) common.CheckError(err)
fmt.Println(string(statusJsonBytes)) fmt.Println(string(statusJSONBytes))
default: default:
// Print endpoint groups in a custom format // Print endpoint groups in a custom format
template, templateParsingErr := template.New("endpointGroupTpl").Parse(viper.GetString("endpoint.group.list.format")) template, templateParsingErr := template.New("endpointGroupTpl").Parse(viper.GetString("endpoint.group.list.format"))

4
cmd/endpointInspect.go
View File

@ -74,9 +74,9 @@ var endpointInspectCmd = &cobra.Command{
common.CheckError(err) common.CheckError(err)
case "json": case "json":
// Print endpoint in a json format // Print endpoint in a json format
endpointJsonBytes, err := json.Marshal(endpoint) endpointJSONBytes, err := json.Marshal(endpoint)
common.CheckError(err) common.CheckError(err)
fmt.Println(string(endpointJsonBytes)) fmt.Println(string(endpointJSONBytes))
default: default:
// Print endpoint in a custom format // Print endpoint in a custom format
template, err := template.New("endpointTpl").Parse(viper.GetString("endpoint.inspect.format")) template, err := template.New("endpointTpl").Parse(viper.GetString("endpoint.inspect.format"))

4
cmd/endpointList.go
View File

@ -71,9 +71,9 @@ var endpointListCmd = &cobra.Command{
common.CheckError(flushErr) common.CheckError(flushErr)
case "json": case "json":
// Print endpoints in a json format // Print endpoints in a json format
statusJsonBytes, err := json.Marshal(endpoints) statusJSONBytes, err := json.Marshal(endpoints)
common.CheckError(err) common.CheckError(err)
fmt.Println(string(statusJsonBytes)) fmt.Println(string(statusJSONBytes))
default: default:
// Print endpoints in a custom format // Print endpoints in a custom format
template, templateParsingErr := template.New("endpointTpl").Parse(viper.GetString("endpoint.list.format")) template, templateParsingErr := template.New("endpointTpl").Parse(viper.GetString("endpoint.list.format"))

8
cmd/stackDeploy.go
View File

@ -56,7 +56,7 @@ var stackDeployCmd = &cobra.Command{
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Debug("Getting endpoint's Docker info") }).Debug("Getting endpoint's Docker info")
endpointSwarmClusterId, selectionErr := common.GetEndpointSwarmClusterId(endpoint.ID) endpointSwarmClusterID, selectionErr := common.GetEndpointSwarmClusterID(endpoint.ID)
if selectionErr == nil { if selectionErr == nil {
// It's a swarm cluster // It's a swarm cluster
} else if selectionErr == common.ErrStackClusterNotFound { } else if selectionErr == common.ErrStackClusterNotFound {
@ -70,7 +70,7 @@ var stackDeployCmd = &cobra.Command{
"stack": stackName, "stack": stackName,
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Debug("Getting stack") }).Debug("Getting stack")
retrievedStack, stackRetrievalErr := common.GetStackByName(stackName, endpointSwarmClusterId, endpoint.ID) retrievedStack, stackRetrievalErr := common.GetStackByName(stackName, endpointSwarmClusterID, endpoint.ID)
if stackRetrievalErr == nil { if stackRetrievalErr == nil {
// We are updating an existing stack // We are updating an existing stack
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
@ -129,13 +129,13 @@ var stackDeployCmd = &cobra.Command{
stackFileContent, loadingErr := loadStackFile(viper.GetString("stack.deploy.stack-file")) stackFileContent, loadingErr := loadStackFile(viper.GetString("stack.deploy.stack-file"))
common.CheckError(loadingErr) common.CheckError(loadingErr)
if endpointSwarmClusterId != "" { if endpointSwarmClusterID != "" {
// It's a swarm cluster // It's a swarm cluster
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
"stack": stackName, "stack": stackName,
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Info("Creating stack") }).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) common.CheckError(deploymentErr)
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
"stack": stack.Name, "stack": stack.Name,

10
cmd/stackInspect.go
View File

@ -24,7 +24,7 @@ var stackInspectCmd = &cobra.Command{
Args: cobra.ExactArgs(1), Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
stackName := args[0] stackName := args[0]
var endpointSwarmClusterId string var endpointSwarmClusterID string
var stack portainer.Stack var stack portainer.Stack
var endpoint portainer.Endpoint var endpoint portainer.Endpoint
@ -51,14 +51,14 @@ var stackInspectCmd = &cobra.Command{
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Debug("Getting endpoint's Docker info") }).Debug("Getting endpoint's Docker info")
var selectionErr, stackRetrievalErr error var selectionErr, stackRetrievalErr error
endpointSwarmClusterId, selectionErr = common.GetEndpointSwarmClusterId(endpoint.ID) endpointSwarmClusterID, selectionErr = common.GetEndpointSwarmClusterID(endpoint.ID)
if selectionErr == nil { if selectionErr == nil {
// It's a swarm cluster // It's a swarm cluster
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
"stack": stackName, "stack": stackName,
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Debug("Getting stack") }).Debug("Getting stack")
stack, stackRetrievalErr = common.GetStackByName(stackName, endpointSwarmClusterId, endpoint.ID) stack, stackRetrievalErr = common.GetStackByName(stackName, endpointSwarmClusterID, endpoint.ID)
} else if selectionErr == common.ErrStackClusterNotFound { } else if selectionErr == common.ErrStackClusterNotFound {
// It's not a swarm cluster // It's not a swarm cluster
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
@ -95,9 +95,9 @@ var stackInspectCmd = &cobra.Command{
common.CheckError(flushErr) common.CheckError(flushErr)
case "json": case "json":
// Print stack in a json format // Print stack in a json format
stackJsonBytes, err := json.Marshal(stack) stackJSONBytes, err := json.Marshal(stack)
common.CheckError(err) common.CheckError(err)
fmt.Println(string(stackJsonBytes)) fmt.Println(string(stackJSONBytes))
default: default:
// Print stack in a custom format // Print stack in a custom format
template, templateParsingErr := template.New("stackTpl").Parse(viper.GetString("stack.inspect.format")) template, templateParsingErr := template.New("stackTpl").Parse(viper.GetString("stack.inspect.format"))

12
cmd/stackList.go
View File

@ -36,7 +36,7 @@ var stackListCmd = &cobra.Command{
endpoints, endpointsRetrievalErr := portainerClient.GetEndpoints() endpoints, endpointsRetrievalErr := portainerClient.GetEndpoints()
common.CheckError(endpointsRetrievalErr) common.CheckError(endpointsRetrievalErr)
var endpointSwarmClusterId string var endpointSwarmClusterID string
var stacks []portainer.Stack var stacks []portainer.Stack
if endpointName := viper.GetString("stack.list.endpoint"); endpointName != "" { if endpointName := viper.GetString("stack.list.endpoint"); endpointName != "" {
// Get endpoint by name // Get endpoint by name
@ -47,13 +47,13 @@ var stackListCmd = &cobra.Command{
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Debug("Getting endpoint's Docker info") }).Debug("Getting endpoint's Docker info")
var selectionErr error var selectionErr error
endpointSwarmClusterId, selectionErr = common.GetEndpointSwarmClusterId(endpoint.ID) endpointSwarmClusterID, selectionErr = common.GetEndpointSwarmClusterID(endpoint.ID)
if selectionErr == nil { if selectionErr == nil {
// It's a swarm cluster // It's a swarm cluster
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Debug("Getting stacks") }).Debug("Getting stacks")
stacks, err = portainerClient.GetStacks(endpointSwarmClusterId, endpoint.ID) stacks, err = portainerClient.GetStacks(endpointSwarmClusterID, endpoint.ID)
common.CheckError(err) common.CheckError(err)
} else if selectionErr == common.ErrStackClusterNotFound { } else if selectionErr == common.ErrStackClusterNotFound {
// It's not a swarm cluster // It's not a swarm cluster
@ -83,7 +83,7 @@ var stackListCmd = &cobra.Command{
}) })
common.CheckError(err) common.CheckError(err)
for _, s := range stacks { for _, s := range stacks {
stackEndpoint, err := common.GetEndpointFromListById(endpoints, s.EndpointID) stackEndpoint, err := common.GetEndpointFromListByID(endpoints, s.EndpointID)
common.CheckError(err) common.CheckError(err)
_, err = fmt.Fprintln(writer, fmt.Sprintf( _, err = fmt.Fprintln(writer, fmt.Sprintf(
"%v\t%s\t%v\t%s", "%v\t%s\t%v\t%s",
@ -98,9 +98,9 @@ var stackListCmd = &cobra.Command{
common.CheckError(flushErr) common.CheckError(flushErr)
case "json": case "json":
// Print stacks in a json format // Print stacks in a json format
stacksJsonBytes, err := json.Marshal(stacks) stacksJSONBytes, err := json.Marshal(stacks)
common.CheckError(err) common.CheckError(err)
fmt.Println(string(stacksJsonBytes)) fmt.Println(string(stacksJSONBytes))
default: default:
// Print stacks in a custom format // Print stacks in a custom format
template, templateParsingErr := template.New("stackTpl").Parse(viper.GetString("stack.list.format")) template, templateParsingErr := template.New("stackTpl").Parse(viper.GetString("stack.list.format"))

10
cmd/stackRemove.go
View File

@ -22,7 +22,7 @@ var stackRemoveCmd = &cobra.Command{
common.CheckError(clientRetrievalErr) common.CheckError(clientRetrievalErr)
stackName := args[0] stackName := args[0]
var endpointSwarmClusterId string var endpointSwarmClusterID string
var stack portainer.Stack var stack portainer.Stack
var endpoint portainer.Endpoint var endpoint portainer.Endpoint
@ -49,14 +49,14 @@ var stackRemoveCmd = &cobra.Command{
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Debug("Getting endpoint's Docker info") }).Debug("Getting endpoint's Docker info")
var selectionErr, stackRetrievalErr error var selectionErr, stackRetrievalErr error
endpointSwarmClusterId, selectionErr = common.GetEndpointSwarmClusterId(endpoint.ID) endpointSwarmClusterID, selectionErr = common.GetEndpointSwarmClusterID(endpoint.ID)
if selectionErr == nil { if selectionErr == nil {
// It's a swarm cluster // It's a swarm cluster
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
"stack": stackName, "stack": stackName,
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Debug("Getting stack") }).Debug("Getting stack")
stack, stackRetrievalErr = common.GetStackByName(stackName, endpointSwarmClusterId, endpoint.ID) stack, stackRetrievalErr = common.GetStackByName(stackName, endpointSwarmClusterID, endpoint.ID)
} else if selectionErr == common.ErrStackClusterNotFound { } else if selectionErr == common.ErrStackClusterNotFound {
// It's not a swarm cluster // It's not a swarm cluster
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
@ -71,13 +71,13 @@ var stackRemoveCmd = &cobra.Command{
if stackRetrievalErr == nil { if stackRetrievalErr == nil {
// The stack exists // The stack exists
stackId := stack.ID stackID := stack.ID
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
"stack": stackName, "stack": stackName,
"endpoint": endpoint.Name, "endpoint": endpoint.Name,
}).Info("Removing stack") }).Info("Removing stack")
err := portainerClient.DeleteStack(stackId) err := portainerClient.DeleteStack(stackID)
common.CheckError(err) common.CheckError(err)
logrus.WithFields(logrus.Fields{ logrus.WithFields(logrus.Fields{
"stack": stack.Name, "stack": stack.Name,

4
cmd/status.go
View File

@ -53,9 +53,9 @@ var statusCmd = &cobra.Command{
common.CheckError(flushErr) common.CheckError(flushErr)
case "json": case "json":
// Print status in a json format // Print status in a json format
statusJsonBytes, err := json.Marshal(respBody) statusJSONBytes, err := json.Marshal(respBody)
common.CheckError(err) common.CheckError(err)
fmt.Println(string(statusJsonBytes)) fmt.Println(string(statusJSONBytes))
default: default:
// Print status in a custom format // Print status in a custom format
template, templateParsingErr := template.New("statusTpl").Parse(viper.GetString("status.format")) template, templateParsingErr := template.New("statusTpl").Parse(viper.GetString("status.format"))

8
common/client.go
View File

@ -36,7 +36,7 @@ func GetDefaultClient() (c client.PortainerClient, err error) {
return return
} }
c = client.NewClient(GetDefaultHttpClient(), config) c = client.NewClient(GetDefaultHTTPClient(), config)
c.BeforeRequest(func(req *http.Request) (err error) { c.BeforeRequest(func(req *http.Request) (err error) {
var bodyString string var bodyString string
@ -84,13 +84,13 @@ func GetDefaultClient() (c client.PortainerClient, err error) {
// Get the default config for a client // Get the default config for a client
func GetDefaultClientConfig() (config client.Config, err error) { 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 { if err != nil {
return return
} }
config = client.Config{ config = client.Config{
Url: apiUrl, URL: apiURL,
User: viper.GetString("user"), User: viper.GetString("user"),
Password: viper.GetString("password"), Password: viper.GetString("password"),
Token: viper.GetString("auth-token"), 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 // Get the default http client for a Portainer client
func GetDefaultHttpClient() *http.Client { func GetDefaultHTTPClient() *http.Client {
return &http.Client{ return &http.Client{
Timeout: viper.GetDuration("timeout"), Timeout: viper.GetDuration("timeout"),
Transport: &http.Transport{ Transport: &http.Transport{

12
common/utils.go
View File

@ -53,13 +53,13 @@ func GetDefaultEndpoint() (endpoint portainer.Endpoint, err error) {
return 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() portainerClient, err := GetClient()
if err != nil { if err != nil {
return return
} }
stacks, err := portainerClient.GetStacks(swarmId, endpointId) stacks, err := portainerClient.GetStacks(swarmID, endpointID)
if err != nil { if err != nil {
return return
} }
@ -113,7 +113,7 @@ func GetEndpointGroupByName(name string) (endpointGroup portainer.EndpointGroup,
return 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 { for i := range endpoints {
if endpoints[i].ID == id { if endpoints[i].ID == id {
return endpoints[i], err return endpoints[i], err
@ -131,14 +131,14 @@ func GetEndpointFromListByName(endpoints []portainer.Endpoint, name string) (end
return endpoint, ErrEndpointNotFound 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 // Get docker information for endpoint
portainerClient, err := GetClient() portainerClient, err := GetClient()
if err != nil { if err != nil {
return return
} }
result, err := portainerClient.GetEndpointDockerInfo(endpointId) result, err := portainerClient.GetEndpointDockerInfo(endpointID)
if err != nil { if err != nil {
return return
} }
@ -146,7 +146,7 @@ func GetEndpointSwarmClusterId(endpointId portainer.EndpointID) (endpointSwarmCl
// Get swarm (if any) information for endpoint // Get swarm (if any) information for endpoint
id, selectionErr := selectValue(result, []string{"Swarm", "Cluster", "ID"}) id, selectionErr := selectValue(result, []string{"Swarm", "Cluster", "ID"})
if selectionErr == nil { if selectionErr == nil {
endpointSwarmClusterId = id.(string) endpointSwarmClusterID = id.(string)
} else if selectionErr == valueNotFoundError { } else if selectionErr == valueNotFoundError {
err = ErrStackClusterNotFound err = ErrStackClusterNotFound
} else { } else {