github.com/spg/deis@v1.7.3/deisctl/config/config.go (about)

     1  package config
     2  
     3  import (
     4  	"encoding/base64"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"strings"
     8  
     9  	"github.com/deis/deis/deisctl/utils"
    10  )
    11  
    12  // fileKeys define config keys to be read from local files
    13  var fileKeys = []string{
    14  	"/deis/platform/sshPrivateKey",
    15  	"/deis/router/sslCert",
    16  	"/deis/router/sslKey"}
    17  
    18  // b64Keys define config keys to be base64 encoded before stored
    19  var b64Keys = []string{"/deis/platform/sshPrivateKey"}
    20  
    21  // Config runs the config subcommand
    22  func Config(args map[string]interface{}) error {
    23  	return doConfig(args)
    24  }
    25  
    26  // CheckConfig looks for a value at a keyspace path
    27  // and returns an error if a value is not found
    28  func CheckConfig(root string, k string) error {
    29  
    30  	client, err := getEtcdClient()
    31  	if err != nil {
    32  		return err
    33  	}
    34  
    35  	_, err = doConfigGet(client, root, []string{k})
    36  	if err != nil {
    37  		return err
    38  	}
    39  
    40  	return nil
    41  }
    42  
    43  func doConfig(args map[string]interface{}) error {
    44  	client, err := getEtcdClient()
    45  	if err != nil {
    46  		return err
    47  	}
    48  
    49  	rootPath := "/deis/" + args["<target>"].(string) + "/"
    50  
    51  	var vals []string
    52  	if args["set"] == true {
    53  		vals, err = doConfigSet(client, rootPath, args["<key=val>"].([]string))
    54  	} else if args["rm"] == true {
    55  		vals, err = doConfigRm(client, rootPath, args["<key>"].([]string))
    56  	} else {
    57  		vals, err = doConfigGet(client, rootPath, args["<key>"].([]string))
    58  	}
    59  	if err != nil {
    60  		return err
    61  	}
    62  
    63  	// print results
    64  	for _, v := range vals {
    65  		fmt.Printf("%v\n", v)
    66  	}
    67  	return nil
    68  }
    69  
    70  func doConfigSet(client *etcdClient, root string, kvs []string) ([]string, error) {
    71  	var result []string
    72  
    73  	for _, kv := range kvs {
    74  
    75  		// split k/v from args
    76  		split := strings.SplitN(kv, "=", 2)
    77  		k, v := split[0], split[1]
    78  
    79  		// prepare path and value
    80  		path := root + k
    81  		val, err := valueForPath(path, v)
    82  		if err != nil {
    83  			return result, err
    84  		}
    85  
    86  		// set key/value in etcd
    87  		ret, err := client.Set(path, val)
    88  		if err != nil {
    89  			return result, err
    90  		}
    91  		result = append(result, ret)
    92  
    93  	}
    94  	return result, nil
    95  }
    96  
    97  func doConfigGet(client *etcdClient, root string, keys []string) ([]string, error) {
    98  	var result []string
    99  	for _, k := range keys {
   100  		val, err := client.Get(root + k)
   101  		if err != nil {
   102  			return result, err
   103  		}
   104  		result = append(result, val)
   105  	}
   106  	return result, nil
   107  }
   108  
   109  func doConfigRm(client *etcdClient, root string, keys []string) ([]string, error) {
   110  	var result []string
   111  	for _, k := range keys {
   112  		err := client.Delete(root + k)
   113  		if err != nil {
   114  			return result, err
   115  		}
   116  		result = append(result, k)
   117  	}
   118  	return result, nil
   119  }
   120  
   121  // valueForPath returns the canonical value for a user-defined path and value
   122  func valueForPath(path string, v string) (string, error) {
   123  
   124  	// check if path is part of fileKeys
   125  	for _, p := range fileKeys {
   126  
   127  		if path == p {
   128  
   129  			// read value from filesystem
   130  			bytes, err := ioutil.ReadFile(utils.ResolvePath(v))
   131  			if err != nil {
   132  				return "", err
   133  			}
   134  
   135  			// see if we should return base64 encoded value
   136  			for _, pp := range b64Keys {
   137  				if path == pp {
   138  					return base64.StdEncoding.EncodeToString(bytes), nil
   139  				}
   140  			}
   141  
   142  			return string(bytes), nil
   143  		}
   144  	}
   145  
   146  	return v, nil
   147  
   148  }