aherman
/
boundary
mirror of https://github.com/hashicorp/boundary
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Minor, easy, linting fixes

Browse Source
pull/243/head
Jeff Mitchell 6 years ago
parent 8dd5de49b9
commit d74e30d94a
6 changed files with 22 additions and 183 deletions
Show Stats Download Patch File Download Diff File

4
internal/cmd/base/base.go
Unescape View File

@ -119,7 +119,9 @@ func (c *Command) Client() (*api.Client, error) {
}
if c.flagAddr != NotSetValue {
c.client.SetAddr(c.flagAddr)
if err := c.client.SetAddr(c.flagAddr); err != nil {
return nil, fmt.Errorf("error setting address on client: %w", err)
}
}
// If we need custom TLS configuration, then set it

30
internal/cmd/base/flags.go
Unescape View File

@ -748,33 +748,3 @@ func (f *FlagSet) Var(value flag.Value, name, usage string) {
f.mainSet.Var(value, name, usage)
f.flagSet.Var(value, name, usage)
}
// -- helpers
func envDefault(key, def string) string {
if v, exist := os.LookupEnv(key); exist {
return v
}
return def
}
func envBoolDefault(key string, def bool) bool {
if v, exist := os.LookupEnv(key); exist {
b, err := strconv.ParseBool(v)
if err != nil {
panic(err)
}
return b
}
return def
}
func envDurationDefault(key string, def time.Duration) time.Duration {
if v, exist := os.LookupEnv(key); exist {
d, err := time.ParseDuration(v)
if err != nil {
panic(err)
}
return d
}
return def
}

4
internal/cmd/base/format.go
Unescape View File

@ -397,9 +397,9 @@ var Formatters = map[string]Formatter{
}
func Format(ui cli.Ui) string {
switch ui.(type) {
switch t := ui.(type) {
case *WatchtowerUI:
return ui.(*WatchtowerUI).Format
return t.Format
}
format := os.Getenv(EnvWatchtowerCLIFormat)

147
internal/cmd/base/helpers.go
Unescape View File

@ -2,62 +2,13 @@ package base
import (
"encoding/json"
"io"
"strings"
"time"
kvbuilder "github.com/hashicorp/vault/internalshared/kv-builder"
"github.com/kr/text"
homedir "github.com/mitchellh/go-homedir"
"github.com/mitchellh/mapstructure"
"github.com/pkg/errors"
"github.com/ryanuber/columnize"
)
// sanitizePath removes any leading or trailing things from a "path".
func sanitizePath(s string) string {
return ensureNoTrailingSlash(ensureNoLeadingSlash(strings.TrimSpace(s)))
}
// ensureTrailingSlash ensures the given string has a trailing slash.
func ensureTrailingSlash(s string) string {
s = strings.TrimSpace(s)
if s == "" {
return ""
}
for len(s) > 0 && s[len(s)-1] != '/' {
s = s + "/"
}
return s
}
// ensureNoTrailingSlash ensures the given string has a trailing slash.
func ensureNoTrailingSlash(s string) string {
s = strings.TrimSpace(s)
if s == "" {
return ""
}
for len(s) > 0 && s[len(s)-1] == '/' {
s = s[:len(s)-1]
}
return s
}
// ensureNoLeadingSlash ensures the given string has a trailing slash.
func ensureNoLeadingSlash(s string) string {
s = strings.TrimSpace(s)
if s == "" {
return ""
}
for len(s) > 0 && s[0] == '/' {
s = s[1:]
}
return s
}
// columnOuput prints the list of items as a table with no headers.
func columnOutput(list []string, c *columnize.Config) string {
if len(list) == 0 {
@ -108,80 +59,6 @@ func tableOutput(list []string, c *columnize.Config) string {
return columnOutput(list, c)
}
// parseArgsData parses the given args in the format key=value into a map of
// the provided arguments. The given reader can also supply key=value pairs.
func parseArgsData(stdin io.Reader, args []string) (map[string]interface{}, error) {
builder := &kvbuilder.Builder{Stdin: stdin}
if err := builder.Add(args...); err != nil {
return nil, err
}
return builder.Map(), nil
}
// parseArgsDataString parses the args data and returns the values as strings.
// If the values cannot be represented as strings, an error is returned.
func parseArgsDataString(stdin io.Reader, args []string) (map[string]string, error) {
raw, err := parseArgsData(stdin, args)
if err != nil {
return nil, err
}
var result map[string]string
if err := mapstructure.WeakDecode(raw, &result); err != nil {
return nil, errors.Wrap(err, "failed to convert values to strings")
}
if result == nil {
result = make(map[string]string)
}
return result, nil
}
// parseArgsDataStringLists parses the args data and returns the values as
// string lists. If the values cannot be represented as strings, an error is
// returned.
func parseArgsDataStringLists(stdin io.Reader, args []string) (map[string][]string, error) {
raw, err := parseArgsData(stdin, args)
if err != nil {
return nil, err
}
var result map[string][]string
if err := mapstructure.WeakDecode(raw, &result); err != nil {
return nil, errors.Wrap(err, "failed to convert values to strings")
}
return result, nil
}
// truncateToSeconds truncates the given duration to the number of seconds. If
// the duration is less than 1s, it is returned as 0. The integer represents
// the whole number unit of seconds for the duration.
func truncateToSeconds(d time.Duration) int {
d = d.Truncate(1 * time.Second)
// Handle the case where someone requested a ridiculously short increment -
// increments must be larger than a second.
if d < 1*time.Second {
return 0
}
return int(d.Seconds())
}
// expandPath takes a filepath and returns the full expanded path, accounting
// for user-relative things like ~/.
func expandPath(s string) string {
if s == "" {
return ""
}
e, err := homedir.Expand(s)
if err != nil {
return s
}
return e
}
// WrapAtLengthWithPadding wraps the given text at the maxLineLength, taking
// into account any provided left padding.
func WrapAtLengthWithPadding(s string, pad int) string {
@ -198,22 +75,6 @@ func WrapAtLength(s string) string {
return WrapAtLengthWithPadding(s, 0)
}
// ttlToAPI converts a user-supplied ttl into an API-compatible string. If
// the TTL is 0, this returns the empty string. If the TTL is negative, this
// returns "system" to indicate to use the system values. Otherwise, the
// time.Duration ttl is used.
func ttlToAPI(d time.Duration) string {
if d == 0 {
return ""
}
if d < 0 {
return "system"
}
return d.String()
}
// humanDuration prints the time duration without those pesky zeros.
func humanDuration(d time.Duration) string {
if d == 0 {
@ -233,13 +94,13 @@ func humanDuration(d time.Duration) string {
// humanDurationInt prints the given int as if it were a time.Duration number
// of seconds.
func humanDurationInt(i interface{}) interface{} {
switch i.(type) {
switch t := i.(type) {
case int:
return humanDuration(time.Duration(i.(int)) * time.Second)
return humanDuration(time.Duration(t) * time.Second)
case int64:
return humanDuration(time.Duration(i.(int64)) * time.Second)
return humanDuration(time.Duration(t) * time.Second)
case json.Number:
if i, err := i.(json.Number).Int64(); err == nil {
if i, err := t.Int64(); err == nil {
return humanDuration(time.Duration(i) * time.Second)
}
}

12
internal/cmd/base/listener.go
Unescape View File

@ -179,12 +179,16 @@ type TCPKeepAliveListener struct {
*net.TCPListener
}
func (ln TCPKeepAliveListener) Accept() (c net.Conn, err error) {
func (ln TCPKeepAliveListener) Accept() (net.Conn, error) {
tc, err := ln.AcceptTCP()
if err != nil {
return
return nil, err
}
if err := tc.SetKeepAlive(true); err != nil {
return nil, err
}
if err := tc.SetKeepAlivePeriod(3 * time.Minute); err != nil {
return nil, err
}
tc.SetKeepAlive(true)
tc.SetKeepAlivePeriod(3 * time.Minute)
return tc, nil
}

8
internal/cmd/base/servers.go
Unescape View File

@ -287,7 +287,7 @@ func (b *Server) SetupListeners(ui cli.Ui, config *configutil.SharedConfig) erro
if lnConfig.MaxRequestDuration == 0 {
lnConfig.MaxRequestDuration = globals.DefaultMaxRequestDuration
}
props["max_request_duration"] = fmt.Sprintf("%s", lnConfig.MaxRequestDuration.String())
props["max_request_duration"] = lnConfig.MaxRequestDuration.String()
b.Listeners = append(b.Listeners, &ServerListener{
Mux: lnMux,
@ -387,7 +387,9 @@ func (b *Server) CreateDevDatabase(dialect string) error {
// In case of an error, run the cleanup function. If we pass all errors, c should be set to a noop
// function before returning from this method
defer func() {
c()
if err := c(); err != nil {
b.Logger.Error("error cleaning up docker container", "error", err)
}
}()
if err != nil {
@ -495,7 +497,7 @@ func (b *Server) CreateDevDatabase(dialect string) error {
if amId == "" {
amId = "paum_1234567890"
}
authMethod, err = pwRepo.CreateAuthMethod(ctx, authMethod, password.WithPublicId(amId))
_, err = pwRepo.CreateAuthMethod(ctx, authMethod, password.WithPublicId(amId))
if err != nil {
return fmt.Errorf("error saving auth method to the db: %w", err)
}

Write Preview
Loading…
Cancel
Save