chore: move pkg from deis/deis to deis/pkg

Author: technosophos

Makefile

@@ -0,0 +1,18 @@
+include ../includes.mk
+
+repo_path = github.com/deis/deis/pkg
+
+GO_PACKAGES = prettyprint time
+GO_PACKAGES_REPO_PATH = $(addprefix $(repo_path)/,$(GO_PACKAGES))
+
+test: test-style test-unit
+
+test-style:
+# display output, then check
+	$(GOFMT) $(GO_PACKAGES)
+	@$(GOFMT) $(GO_PACKAGES) | read; if [ $$? == 0 ]; then echo "gofmt check failed."; exit 1; fi
+	$(GOVET) $(GO_PACKAGES_REPO_PATH)
+	$(GOLINT) ./...
+
+test-unit:
+	$(GOTEST) ./...

aboutme/README.md

@@ -0,0 +1,7 @@
+# aboutme: Self-discovery for Kubernetes containers
+
+This library provides hooks for containers to learn about themselves and
+their pods.
+
+Essentially, this uses environmental data to connect to a k8s API server
+and find out about the current pod's configuration.

aboutme/aboutme.go

@@ -0,0 +1,187 @@
+// Package aboutme provides information to a pod about itself.
+//
+// Typical usage is to let the Pod auto-detect information about itself:
+//
+//	my, err := aboutme.FromEnv()
+//  if err != nil {
+// 		// Error connecting to tke k8s API server
+// 	}
+//
+// 	fmt.Printf("My Pod Name is %s", my.Name)
+package aboutme
+
+import (
+	"errors"
+	"net"
+	"os"
+	"strings"
+
+	"github.com/deis/deis/pkg/k8s"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/client/unversioned"
+	"k8s.io/kubernetes/pkg/labels"
+)
+
+type Me struct {
+	ApiServer, Name                      string
+	IP, NodeIP, Namespace, SelfLink, UID string
+	Labels                               map[string]string
+	Annotations                          map[string]string
+
+	c *unversioned.Client
+}
+
+// FromEnv uses the environment to create a new Me.
+//
+// To use this, a client MUST be running inside of a Pod environment. It uses
+// a combination of environment variables and file paths to determine
+// information about the cluster.
+func FromEnv() (*Me, error) {
+
+	host := os.Getenv("KUBERNETES_SERVICE_HOST")
+	port := os.Getenv("KUBERNETES_SERVICE_PORT")
+	name := os.Getenv("HOSTNAME")
+
+	// FIXME: Better way? Probably scanning secrets for
+	// an SSL cert would help?
+	proto := "https"
+
+	url := proto + "://" + host + ":" + port
+
+	me := &Me{
+		ApiServer: url,
+		Name:      name,
+
+		// FIXME: This is a chicken-and-egg problem. We need the namespace
+		// to get pod info, and we can only get info from the pod.
+		Namespace: "default",
+	}
+
+	client, err := k8s.PodClient()
+	if err != nil {
+		return me, err
+	}
+	me.c = client
+
+	me.init()
+
+	return me, nil
+}
+
+// Client returns an initialized Kubernetes API client.
+func (me *Me) Client() *unversioned.Client {
+	return me.c
+}
+
+// ShuntEnv puts the Me object into the environment.
+//
+// The properties of Me are placed into the environment according to the
+// following rules:
+//
+// 	- In general, all variables are prefaced with MY_ (MY_IP, MY_NAMESPACE)
+// 	- Labels become MY_LABEL_[NAME]=[value]
+// 	- Annotations become MY_ANNOTATION_[NAME] = [value]
+func (me *Me) ShuntEnv() {
+	env := map[string]string{
+		"MY_APISERVER": me.ApiServer,
+		"MY_NAME":      me.Name,
+		"MY_IP":        me.IP,
+		"MY_NODEIP":    me.NodeIP,
+		"MY_NAMESPACE": me.Namespace,
+		"MY_SELFLINK":  me.SelfLink,
+		"MY_UID":       me.UID,
+	}
+	for k, v := range env {
+		os.Setenv(k, v)
+	}
+	var name string
+	for k, v := range me.Labels {
+		name = "MY_LABEL_" + strings.ToUpper(k)
+		os.Setenv(name, v)
+	}
+	for k, v := range me.Annotations {
+		name = "MY_ANNOTATION_" + strings.ToUpper(k)
+		os.Setenv(name, v)
+	}
+}
+
+func (me *Me) init() error {
+	p, n, err := me.findPodInNamespaces()
+	if err != nil {
+		return err
+	}
+
+	me.Namespace = n
+	me.IP = p.Status.PodIP
+	me.NodeIP = p.Status.HostIP
+	me.SelfLink = p.SelfLink
+	me.UID = string(p.UID)
+	me.Labels = p.Labels
+	me.Annotations = me.Annotations
+
+	return nil
+}
+
+// findPodInNamespaces searches relevant namespaces for this pod.
+//
+// It returns a PodInterface for working with the pod, a namespace name as a
+// string, and an error if something goes wrong.
+//
+// The search pattern is to look for namespaces that have the "deis" name in
+// their labels, and then to fall back to default. We don't look at all
+// namespaces.
+func (me *Me) findPodInNamespaces() (*api.Pod, string, error) {
+	// Get the deis namespace. If it does not exist, get the default namespce.
+	s, err := labels.Parse("name=deis")
+	if err == nil {
+		ns, err := me.c.Namespaces().List(s, nil)
+		if err != nil {
+			return nil, "default", err
+		}
+		for _, n := range ns.Items {
+			p, err := me.c.Pods(n.Name).Get(me.Name)
+
+			// If there is no error, we got a matching pod.
+			if err == nil {
+				return p, n.Name, nil
+			}
+		}
+	}
+
+	// If we get here, it's really the last ditch.
+	p, err := me.c.Pods("default").Get(me.Name)
+	return p, "default", err
+}
+
+// MyIP examines the local interfaces and guesses which is its IP.
+//
+// Containers tend to put the IP address in eth0, so this attempts to look up
+// that interface and retrieve its IP. It is fairly naive. To get more
+// thorough IP information, you may prefer to use the `net` package and
+// look up the desired information.
+//
+// Because this queries the interfaces, not the Kube API server, this could,
+// in theory, return an IP address different from Me.IP.
+func MyIP() (string, error) {
+	iface, err := net.InterfaceByName("eth0")
+	if err != nil {
+		return "", err
+	}
+	addrs, err := iface.Addrs()
+	if err != nil {
+		return "", err
+	}
+	var ip string
+	for _, a := range addrs {
+		if ipnet, ok := a.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
+			if ipnet.IP.To4() != nil {
+				ip = ipnet.IP.String()
+			}
+		}
+	}
+	if len(ip) == 0 {
+		return ip, errors.New("Found no IPv4 addresses.")
+	}
+	return ip, nil
+}

aboutme/aboutme_test.go

@@ -0,0 +1,59 @@
+package aboutme
+
+import (
+	"net"
+	"os"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/client/unversioned"
+)
+
+func TestFromEnv(t *testing.T) {
+	if _, err := unversioned.InClusterConfig(); err != nil {
+		t.Skip("This can only be run inside Kubernetes. Skipping.")
+	}
+
+	me, err := FromEnv()
+	if err != nil {
+		t.Errorf("Could not get an environment: %s", err)
+	}
+	if len(me.Name) == 0 {
+		t.Error("Could not get a pod name.")
+	}
+}
+
+func TestShuntEnv(t *testing.T) {
+	e := &Me{
+		Annotations: map[string]string{"a": "a"},
+		Labels:      map[string]string{"b": "b"},
+		Name:        "c",
+	}
+
+	e.ShuntEnv()
+
+	if "a" != os.Getenv("MY_ANNOTATION_A") {
+		t.Errorf("Expected 'a', got '%s'", os.Getenv("MY_ANNOTATION_A"))
+	}
+	if "b" != os.Getenv("MY_LABEL_B") {
+		t.Errorf("Expected 'b', got '%s'", os.Getenv("MY_LABEL_B"))
+	}
+
+	if "c" != os.Getenv("MY_NAME") {
+		t.Errorf("Expected 'c', got '%s'", os.Getenv("MY_NAME"))
+	}
+}
+
+func TestMyIP(t *testing.T) {
+	if _, err := net.InterfaceByName("eth0"); err != nil {
+		t.Skip("Host operating system does not have an eth0 device to test.")
+	}
+
+	ip, err := MyIP()
+	if err != nil {
+		t.Errorf("Could not get IP address: %s", err)
+	}
+
+	if len(ip) == 0 {
+		t.Errorf("Expected a valid IP address. Got nuthin.")
+	}
+}

env/envvar.go

@@ -0,0 +1,100 @@
+package env
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/Masterminds/cookoo"
+	"github.com/Masterminds/cookoo/log"
+)
+
+// Get gets one or more environment variables and puts them into the context.
+//
+// Parameters passed in are of the form varname => defaultValue.
+//
+// 	r.Route("foo", "example").Does(envvar.Get).Using("HOME").WithDefault(".")
+//
+// As with all environment variables, the default value must be a string.
+//
+// WARNING: Since parameters are a map, order of processing is not
+// guaranteed. If order is important, you'll need to call this command
+// multiple times.
+//
+// For each parameter (`Using` clause), this command will look into the
+// environment for a matching variable. If it finds one, it will add that
+// variable to the context. If it does not find one, it will expand the
+// default value (so you can set a default to something like "$HOST:$PORT")
+// and also put the (unexpanded) default value back into the context in case
+// any subsequent call to `os.Getenv` occurs.
+func Get(c cookoo.Context, params *cookoo.Params) (interface{}, cookoo.Interrupt) {
+	for name, def := range params.AsMap() {
+		var val string
+		if val = os.Getenv(name); len(val) == 0 {
+			if def == nil {
+				def = ""
+			}
+			def, ok := def.(string)
+			if !ok {
+				log.Warnf(c, "Could not convert %s. Type is %T", name, def)
+			}
+			val = os.ExpandEnv(def)
+			// We want to make sure that any subsequent calls to Getenv
+			// return the same default.
+			os.Setenv(name, val)
+
+		}
+		c.Put(name, val)
+		log.Debugf(c, "Name: %s, Val: %s", name, val)
+	}
+	return true, nil
+}
+
+// Expand expands the environment variables in the given string and returns the result.
+//
+// Params:
+// 	- content (string): The given string to expand.
+//
+// Returns:
+//  - The expanded string. This expands against the os environemnt (os.ExpandEnv).
+func Expand(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
+	s := p.Get("content", "").(string)
+
+	// TODO: We could easily add support here for Expand().
+
+	return os.ExpandEnv(s), nil
+}
+
+// Set takes the given names and values and puts them into both the context
+// and the environment.
+//
+// Unlike Get, it does not try to retrieve the values from the environment
+// first.
+//
+// Values are passed through os.ExpandEnv()
+//
+// There is no guarantee of insertion order. If multiple name/value pairs
+// are given, they will be put into the context in whatever order they
+// are retrieved from the underlying map.
+//
+// Params:
+//   accessed as map[string]string
+// Returns:
+//   nothing, but inserts all name/value pairs into the context and the
+//   environment.
+func Set(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
+	for name, def := range p.AsMap() {
+		// Assume Nil means unset the value.
+		if def == nil {
+			def = ""
+		}
+
+		val := fmt.Sprintf("%v", def)
+		val = os.ExpandEnv(val)
+		log.Debugf(c, "Name: %s, Val: %s", name, val)
+
+		os.Setenv(name, val)
+		c.Put(name, val)
+	}
+	return true, nil
+
+}