args.go

// Copyright 2015 Zalando SE
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package main

import (
	"errors"
	"flag"
	"net/url"
	"os"
	"regexp"
	"strings"

	terminal "golang.org/x/term"
)

const (
	etcdUrlsFlag       = "etcd-urls"
	etcdPrefixFlag     = "etcd-prefix"
	etcdOAuthTokenFlag = "etcd-oauth-token"
	innkeeperUrlFlag   = "innkeeper-url"
	oauthTokenFlag     = "oauth-token"
	inlineRoutesFlag   = "routes"
	inlineIdsFlag      = "ids"
	insecureFlag       = "insecure"
	prependFiltersFlag = "prepend"
	prependFileFlag    = "prepend-file"
	appendFiltersFlag  = "append"
	appendFileFlag     = "append-file"
	prettyFlag         = "pretty"
	sortPredicatesFlag = "sort-predicates"
	indentStrFlag      = "indent"
	jsonFlag           = "json"

	defaultEtcdUrls     = "http://127.0.0.1:2379,http://127.0.0.1:4001"
	defaultEtcdPrefix   = "/skipper"
	defaultInnkeeperUrl = "http://127.0.0.1:8080"
)

// used to prevent flag.FlagSet of printing errors in the wrong place
type noopWriter struct{}

func (w *noopWriter) Write(b []byte) (int, error) {
	return len(b), nil
}

var (
	invalidNumberOfArgs = errors.New("invalid number of args")
	missingOAuthToken   = errors.New("missing OAuth token")
	invalidIndentStr    = errors.New("invalid indent. Must match regexp \\s")
)

// parsing vars for flags:
var (
	etcdUrls          string
	etcdPrefix        string
	innkeeperUrl      string
	oauthToken        string
	etcdOAuthToken    string
	inlineRoutes      string
	inlineRouteIds    string
	insecure          bool
	prependFiltersArg string
	prependFileArg    string
	appendFiltersArg  string
	appendFileArg     string
	pretty            bool
	sortPredicates    bool
	indentStr         string
	printJson         bool
)

var (
	// used to prevent automatic stdin detection during tests:
	isTest = false

	nowrite = &noopWriter{}
	flags   *flag.FlagSet
)

func initFlags() {
	flags = &flag.FlagSet{Usage: func() {}}
	flags.SetOutput(nowrite)

	// the default value not used here, because it depends on the command
	flags.StringVar(&etcdUrls, etcdUrlsFlag, "", etcdUrlsUsage)
	flags.StringVar(&etcdPrefix, etcdPrefixFlag, "", etcdPrefixUsage)
	flags.StringVar(&etcdOAuthToken, etcdOAuthTokenFlag, "", etcdOAuthTokenUsage)

	flags.StringVar(&innkeeperUrl, innkeeperUrlFlag, "", innkeeperUrlUsage)
	flags.StringVar(&oauthToken, oauthTokenFlag, "", oauthTokenUsage)

	flags.StringVar(&inlineRoutes, inlineRoutesFlag, "", inlineRoutesUsage)
	flags.StringVar(&inlineRouteIds, inlineIdsFlag, "", inlineIdsUsage)

	flags.BoolVar(&insecure, insecureFlag, false, insecureUsage)

	flags.StringVar(&prependFiltersArg, prependFiltersFlag, "", prependFiltersUsage)
	flags.StringVar(&prependFileArg, prependFileFlag, "", prependFileUsage)
	flags.StringVar(&appendFiltersArg, appendFiltersFlag, "", appendFiltersUsage)
	flags.StringVar(&appendFileArg, appendFileFlag, "", appendFileUsage)

	flags.BoolVar(&pretty, prettyFlag, false, prettyUsage)
	flags.BoolVar(&sortPredicates, sortPredicatesFlag, false, sortPredicateUsage)
	flags.StringVar(&indentStr, indentStrFlag, "  ", indentStrUsage)
	flags.BoolVar(&printJson, jsonFlag, false, jsonUsage)
}

func init() {
	initFlags()
}

func urlsToStrings(urls []*url.URL) []string {
	surls := make([]string, len(urls))
	for i, u := range urls {
		surls[i] = u.String()
	}

	return surls
}

func stringsToUrls(strs ...string) ([]*url.URL, error) {
	urls := make([]*url.URL, len(strs))
	for i, su := range strs {
		u, err := url.Parse(su)
		if err != nil {
			return nil, err
		}

		urls[i] = u
	}

	return urls, nil
}

// returns etcd type medium if any of '-etcd-urls' or '-etcd-prefix'
// are defined.
func processEtcdArgs(etcdUrls, etcdPrefix, oauthToken string) (*medium, error) {
	if etcdUrls == "" && etcdPrefix == "" {
		return nil, nil
	}

	if etcdUrls == "" {
		etcdUrls = defaultEtcdUrls
	}

	if etcdPrefix == "" {
		etcdPrefix = defaultEtcdPrefix
	}

	surls := strings.Split(etcdUrls, ",")
	urls, err := stringsToUrls(surls...)
	if err != nil {
		return nil, err
	}

	return &medium{
		typ:        etcd,
		urls:       urls,
		path:       etcdPrefix,
		oauthToken: oauthToken}, nil
}

func processInnkeeperArgs(innkeeperUrl, oauthToken string) (*medium, error) {
	if innkeeperUrl == "" && oauthToken == "" {
		return nil, nil
	}

	if oauthToken == "" {
		return nil, missingOAuthToken
	}

	if innkeeperUrl == "" {
		innkeeperUrl = defaultInnkeeperUrl
	}

	urls, err := stringsToUrls(innkeeperUrl)
	if err != nil {
		return nil, err
	}

	return &medium{
		typ:        innkeeper,
		urls:       urls,
		oauthToken: oauthToken}, nil
}

// returns file type medium if a positional parameter is defined.
func processFileArg() (*medium, error) {
	nonFlagArgs := flags.Args()
	if len(nonFlagArgs) > 1 {
		return nil, invalidNumberOfArgs
	}

	if len(nonFlagArgs) == 0 {
		return nil, nil
	}

	return &medium{
		typ:  file,
		path: nonFlagArgs[0]}, nil
}

// if pretty print then check that indent matches pattern
func processIndentStr() error {
	if pretty && !(regexp.MustCompile(`^[\s]*$`).MatchString(indentStr)) {
		return invalidIndentStr
	}
	return nil

}

// returns stdin type medium if stdin is not TTY.
func processStdin() *medium {

	// what can go wrong
	fdint := int(os.Stdin.Fd())

	if isTest || terminal.IsTerminal(fdint) {
		return nil
	}

	return &medium{typ: stdin}
}

func processPatchArgs(pfilters, pfile, afilters, afile string) []*medium {
	var media []*medium

	if pfilters != "" {
		media = append(media, &medium{typ: patchPrepend, patchFilters: pfilters})
	}

	if afilters != "" {
		media = append(media, &medium{typ: patchAppend, patchFilters: afilters})
	}

	if pfile != "" {
		media = append(media, &medium{typ: patchPrependFile, patchFile: pfile})
	}

	if afile != "" {
		media = append(media, &medium{typ: patchAppendFile, patchFile: afile})
	}

	return media
}

// returns media detected from the executing command.
func processArgs() ([]*medium, error) {
	err := flags.Parse(os.Args[2:])
	if err != nil {
		return nil, err
	}

	var media []*medium

	innkeeperArg, err := processInnkeeperArgs(innkeeperUrl, oauthToken)

	if err != nil {
		return nil, err
	}

	if innkeeperArg != nil {
		media = append(media, innkeeperArg)
	}

	etcdArg, err := processEtcdArgs(etcdUrls, etcdPrefix, etcdOAuthToken)
	if err != nil {
		return nil, err
	}

	if etcdArg != nil {
		media = append(media, etcdArg)
	}

	if inlineRoutes != "" {
		media = append(media, &medium{
			typ:   inline,
			eskip: inlineRoutes})
	}

	if inlineRouteIds != "" {
		media = append(media, &medium{
			typ: inlineIds,
			ids: strings.Split(inlineRouteIds, ",")})
	}

	fileArg, err := processFileArg()
	if err != nil {
		return nil, err
	}

	err = processIndentStr()
	if err != nil {
		return nil, err
	}

	if fileArg != nil {
		media = append(media, fileArg)
	} else {
		stdinArg := processStdin()

		if stdinArg != nil {
			media = append(media, stdinArg)
		}
	}

	patchMedia := processPatchArgs(
		prependFiltersArg, prependFileArg, appendFiltersArg, appendFileArg)
	media = append(media, patchMedia...)

	return media, nil
}