├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── NOTICE
├── README.md
├── backends.go
├── build
├── nsproxy.go
├── third_party.go
├── third_party
    └── src
    │   ├── bitbucket.org
    │       └── kardianos
    │       │   └── osext
    │       │       ├── LICENSE
    │       │       ├── osext.go
    │       │       ├── osext_plan9.go
    │       │       ├── osext_procfs.go
    │       │       ├── osext_sysctl.go
    │       │       ├── osext_test.go
    │       │       └── osext_windows.go
    │   └── github.com
    │       ├── codegangsta
    │           └── cli
    │           │   ├── .travis.yml
    │           │   ├── LICENSE
    │           │   ├── README.md
    │           │   ├── app.go
    │           │   ├── app_test.go
    │           │   ├── cli.go
    │           │   ├── cli_test.go
    │           │   ├── command.go
    │           │   ├── context.go
    │           │   ├── context_test.go
    │           │   ├── flag.go
    │           │   ├── flag_test.go
    │           │   ├── help.go
    │           │   └── helpers_test.go
    │       └── coreos
    │           ├── go-etcd
    │               ├── .gitignore
    │               ├── LICENSE
    │               ├── README.md
    │               └── etcd
    │               │   ├── add_child.go
    │               │   ├── add_child_test.go
    │               │   ├── client.go
    │               │   ├── client_test.go
    │               │   ├── compare_and_swap.go
    │               │   ├── compare_and_swap_test.go
    │               │   ├── debug.go
    │               │   ├── delete.go
    │               │   ├── delete_test.go
    │               │   ├── error.go
    │               │   ├── get.go
    │               │   ├── get_test.go
    │               │   ├── options.go
    │               │   ├── requests.go
    │               │   ├── response.go
    │               │   ├── set_curl_chan_test.go
    │               │   ├── set_update_create.go
    │               │   ├── set_update_create_test.go
    │               │   ├── version.go
    │               │   ├── watch.go
    │               │   └── watch_test.go
    │           ├── go-log
    │               ├── .gitignore
    │               ├── LICENSE
    │               ├── README.md
    │               └── log
    │               │   ├── commands.go
    │               │   ├── fields.go
    │               │   ├── logger.go
    │               │   ├── priority.go
    │               │   └── sinks.go
    │           ├── go-namespaces
    │               ├── LICENSE
    │               ├── README.md
    │               ├── build
    │               ├── namespace
    │               │   ├── linux_x86_64.go
    │               │   └── namespace.go
    │               ├── net
    │               │   └── net.go
    │               ├── nspipe
    │               │   └── nspipe.go
    │               ├── third_party.go
    │               └── third_party
    │               │   └── src
    │               │       └── github.com
    │               │           └── coreos
    │               │               └── go-namespaces
    │           ├── go-systemd
    │               ├── LICENSE
    │               ├── README.md
    │               ├── activation
    │               │   ├── files.go
    │               │   └── files_test.go
    │               ├── dbus
    │               │   ├── dbus.go
    │               │   ├── methods.go
    │               │   ├── properties.go
    │               │   └── subscription.go
    │               ├── examples
    │               │   └── activation
    │               │   │   ├── activation.go
    │               │   │   └── httpserver
    │               │   │       ├── README.md
    │               │   │       ├── hello.service
    │               │   │       ├── hello.socket
    │               │   │       └── httpserver.go
    │               ├── journal
    │               │   └── send.go
    │               └── test
    │           └── nsproxy
└── util.go


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | 
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 | 
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 | 
20 | _testmain.go
21 | 
22 | *.exe
23 | 
24 | /nsproxy
25 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
  1 | # How to contribute
  2 | 
  3 | CoreOS projects are Apache 2.0 licensed and accept contributions via Github
  4 | pull requests.  This document outlines some of the conventions on commit
  5 | message formatting, contact points for developers and other resources to make
  6 | getting your contribution accepted.
  7 | 
  8 | # Certificate of Origin
  9 | 
 10 | By contributing to this project you agree to the Developer Certificate of
 11 | Origin (DCO). This document was created by the Linux Kernel community and is a
 12 | simple statement that you, as a contributor, have the legal right to make the
 13 | contribution.
 14 | 
 15 | ```
 16 | Developer Certificate of Origin
 17 | Version 1.1
 18 | 
 19 | Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
 20 | 660 York Street, Suite 102,
 21 | San Francisco, CA 94110 USA
 22 | 
 23 | Everyone is permitted to copy and distribute verbatim copies of this
 24 | license document, but changing it is not allowed.
 25 | 
 26 | 
 27 | Developer's Certificate of Origin 1.1
 28 | 
 29 | By making a contribution to this project, I certify that:
 30 | 
 31 | (a) The contribution was created in whole or in part by me and I
 32 |     have the right to submit it under the open source license
 33 |     indicated in the file; or
 34 | 
 35 | (b) The contribution is based upon previous work that, to the best
 36 |     of my knowledge, is covered under an appropriate open source
 37 |     license and I have the right under that license to submit that
 38 |     work with modifications, whether created in whole or in part
 39 |     by me, under the same open source license (unless I am
 40 |     permitted to submit under a different license), as indicated
 41 |     in the file; or
 42 | 
 43 | (c) The contribution was provided directly to me by some other
 44 |     person who certified (a), (b) or (c) and I have not modified
 45 |     it.
 46 | 
 47 | (d) I understand and agree that this project and the contribution
 48 |     are public and that a record of the contribution (including all
 49 |     personal information I submit with it, including my sign-off) is
 50 |     maintained indefinitely and may be redistributed consistent with
 51 |     this project or the open source license(s) involved.
 52 | ```
 53 | 
 54 | 
 55 | # Email and chat
 56 | 
 57 | - Email: [coreos-dev](https://groups.google.com/forum/#!forum/coreos-dev)
 58 | - IRC: #[coreos](irc://irc.freenode.org:6667/#coreos) IRC channel on freenode.org
 59 | 
 60 | ## Getting Started
 61 | 
 62 | - Fork the repository on GitHub
 63 | - Read the README.md for build instructions
 64 | 
 65 | ## Contribution flow
 66 | 
 67 | This is a rough outline of what a contributor's workflow looks like:
 68 | 
 69 | - Create a topic branch from where you want to base your work. This is usually master.
 70 | - Make commits of logical units.
 71 | - Make sure your commit messages are in the proper format, see below
 72 | - Push your changes to a topic branch in your fork of the repository.
 73 | - Submit a pull request
 74 | 
 75 | Thanks for you contributions!
 76 | 
 77 | ### Format of the commit message
 78 | 
 79 | We follow a rough convention for commit messages borrowed from Angularjs. This
 80 | is an example of a commit:
 81 | 
 82 | ```
 83 |     feat(scripts/test-cluster): add a cluster test command
 84 | 
 85 |     this uses tmux to setup a test cluster that you can easily kill and
 86 |     start for debugging.
 87 | ```
 88 | 
 89 | To make it more formal it looks something like this:
 90 | 
 91 | ```
 92 | <type>(<scope>): <subject>
 93 | <BLANK LINE>
 94 | <body>
 95 | <BLANK LINE>
 96 | <footer>
 97 | ```
 98 | 
 99 | The first line is the subject and should not be longer than 70 characters, the
100 | second line is always blank and other lines should be wrapped at 80 characters.
101 | This allows the message to be easier to read on github as well as in various
102 | git tools.
103 | 
104 | ### Subject line
105 | 
106 | The subject line contains succinct description of the change.
107 | 
108 | ### Allowed <type>
109 | - feat (feature)
110 | - fix (bug fix)
111 | - docs (documentation)
112 | - style (formatting, missing semi colons, …)
113 | - refactor
114 | - test (when adding missing tests)
115 | - chore (maintain)
116 | 
117 | ### Allowed <scope>
118 | 
119 | Scopes could be anything specifying place of the commit change. For example store, api, etc.
120 | 
121 | ### More details on commits
122 | 
123 | For more details see the [angularjs commit style
124 | guide](https://docs.google.com/a/coreos.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit#).
125 | 


--------------------------------------------------------------------------------
/NOTICE:
--------------------------------------------------------------------------------
1 | nsproxy
2 | Copyright 2014 CoreOS, Inc
3 | 
4 | This product includes software developed at CoreOS, Inc.
5 | (http://www.coreos.com/).
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | nsproxy
2 | =======
3 | 
4 | Linux namespaces tcp proxy
5 | 


--------------------------------------------------------------------------------
/backends.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"log"
  6 | 	"net"
  7 | 	"strconv"
  8 | 	"sync"
  9 | 
 10 | 	"github.com/coreos/go-etcd/etcd"
 11 | )
 12 | 
 13 | type service struct {
 14 | 	Host string `json:"host"`
 15 | 	Port int `json:"port"`
 16 | }
 17 | 
 18 | type host struct {
 19 | 	key string
 20 | 	addr string
 21 | }
 22 | 
 23 | type backends struct {
 24 | 	path       string
 25 | 	hosts      []host
 26 | 	lastIndex  int
 27 | 	watchIndex uint64
 28 | 	lock       sync.RWMutex
 29 | }
 30 | 
 31 | func (b *backends) Dump(action string ) {
 32 | 	for _, v := range(b.hosts) {
 33 | 		log.Printf("Dump after %s %s -> %s", action, v.key, v.addr)
 34 | 	}
 35 | }
 36 | 
 37 | func (b *backends) Remove(key string) {
 38 | 	match := -1
 39 | 	for k, v := range(b.hosts) {
 40 | 		if v.key == key {
 41 | 			match = k
 42 | 		}
 43 | 	}
 44 | 
 45 | 	b.hosts = append(b.hosts[:match], b.hosts[match+1:]...)
 46 | 	b.Dump("remove")
 47 | }
 48 | 
 49 | func (b *backends) Update(node *etcd.Node, action string) {
 50 | 	b.lock.Lock()
 51 | 	defer b.lock.Unlock()
 52 | 
 53 | 	log.Printf("key: %s action: %s value: %s", node.Key, action, string(node.Value))
 54 | 
 55 | 	s := &service{}
 56 | 	if action == "delete" || action == "expire" {
 57 | 		b.Remove(node.Key)
 58 | 		return
 59 | 	}
 60 | 
 61 | 	err := json.Unmarshal([]byte(node.Value), s)
 62 | 	if err != nil {
 63 | 		panic(err)
 64 | 	}
 65 | 
 66 | 	addr := net.JoinHostPort(s.Host, strconv.Itoa(s.Port))
 67 | 
 68 | 
 69 | 	// TODO: create an actual set data structure
 70 | 	for _, v := range(b.hosts) {
 71 | 		if v.key == node.Key {
 72 | 			b.Dump(action)
 73 | 			return
 74 | 		}
 75 | 	}
 76 | 
 77 | 	b.hosts = append(b.hosts, host{addr: addr, key: node.Key})
 78 | }
 79 | 
 80 | func (b *backends) Watch(client *etcd.Client) {
 81 | 	receiver := make(chan *etcd.Response)
 82 | 	go client.Watch(b.path, uint64(b.watchIndex), true, receiver, nil)
 83 | 
 84 | 	for {
 85 | 		resp := <-receiver
 86 | 		b.Update(resp.Node, resp.Action)
 87 | 	}
 88 | }
 89 | 
 90 | func (b *backends) Sync(client *etcd.Client) error {
 91 | 	resp, err := client.Get(b.path, false, true)
 92 | 
 93 | 	if err != nil {
 94 | 		return err
 95 | 	}
 96 | 
 97 | 	for _, n := range(resp.Node.Nodes) {
 98 | 		b.Update(&n, resp.Action)
 99 | 	}
100 | 
101 | 	// Begin the watch after this sync from the next sync
102 | 	b.watchIndex = resp.EtcdIndex + 1
103 | 
104 | 	return nil
105 | }
106 | 
107 | func (b *backends) Next() string {
108 | 	b.lock.RLock()
109 | 	defer b.lock.RUnlock()
110 | 
111 | 	if len(b.hosts) == 0 {
112 | 		return ""
113 | 	}
114 | 
115 | 	index := (b.lastIndex + 1) % len(b.hosts)
116 | 	b.lastIndex = index
117 | 
118 | 	return b.hosts[index].addr
119 | }
120 | 


--------------------------------------------------------------------------------
/build:
--------------------------------------------------------------------------------
1 | go run third_party.go build .
2 | 


--------------------------------------------------------------------------------
/nsproxy.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"io"
  6 | 	"log"
  7 | 	"net"
  8 | 	"os"
  9 | 
 10 | 	"github.com/codegangsta/cli"
 11 | 	"github.com/coreos/go-etcd/etcd"
 12 | 	nameNet "github.com/coreos/go-namespaces/net"
 13 | 	"github.com/coreos/go-namespaces/namespace"
 14 | )
 15 | 
 16 | func proxyConn(conn *net.Conn, addr string) {
 17 | 	rConn, err := net.Dial("tcp", addr)
 18 | 	if err != nil {
 19 | 		log.Printf(err.Error())
 20 | 		(*conn).Close()
 21 | 		return
 22 | 	}
 23 | 
 24 | 	go io.Copy(rConn, *conn)
 25 | 	go io.Copy(*conn, rConn)
 26 | }
 27 | 
 28 | func proxy(c *cli.Context) {
 29 | 	addr := c.String("addr")
 30 | 	namespacePid := c.Int("namespace-pid")
 31 | 	namespacePath := c.String("namespace-path")
 32 | 	if namespacePid == 0 && namespacePath == "" {
 33 | 		fmt.Fprintln(os.Stderr, "error: a namespace pid or path is required")
 34 | 		return
 35 | 	}
 36 | 
 37 | 	path := c.String("path")
 38 | 	if path == "" {
 39 | 		fmt.Fprintln(os.Stderr, "error: an etcd path is required")
 40 | 		return
 41 | 	}
 42 | 
 43 | 	if namespacePid != 0 {
 44 | 		p, err := namespace.ProcessPath(namespacePid, namespace.CLONE_NEWNET)
 45 | 		if err != nil {
 46 | 			panic(err)
 47 | 		}
 48 | 		namespacePath = p
 49 | 	}
 50 | 
 51 | 	peers := trimsplit(c.String("peers"), ",")
 52 | 	client := etcd.NewClient(peers)
 53 | 
 54 | 	log.Printf("Proxying for keys in %s on host %s", path, addr)
 55 | 
 56 | 	// Keep an eye on the backend path
 57 | 	b := backends{path: path}
 58 | 	err := b.Sync(client)
 59 | 	if err != nil {
 60 | 		log.Fatal(err)
 61 | 	}
 62 | 
 63 | 	go b.Watch(client)
 64 | 
 65 | 	log.Printf("Proxying for keys in %s on host %s in namespace %d", path, addr, namespacePath)
 66 | 	listener, err := nameNet.ListenNamespace(namespacePath, "tcp", addr)
 67 | 
 68 | 	if err != nil {
 69 | 		panic(err)
 70 | 	}
 71 | 
 72 | 	for {
 73 | 		// Wait for a connection.
 74 | 		conn, err := listener.Accept()
 75 | 		if err != nil {
 76 | 			log.Fatal(err)
 77 | 		}
 78 | 
 79 | 		next := b.Next()
 80 | 		if next == "" {
 81 | 			conn.Close()
 82 | 			log.Printf("No backends! Closing the connection")
 83 | 			continue
 84 | 		}
 85 | 
 86 | 		log.Printf("PROXY: targetAddr:%v addr:%v\n", addr, next)
 87 | 		go proxyConn(&conn, next)
 88 | 	}
 89 | }
 90 | 
 91 | func main() {
 92 | 	app := cli.NewApp()
 93 | 	app.Name = "nsproxy"
 94 | 	app.Usage = "Proxy into a network namespace"
 95 | 	app.Flags = []cli.Flag{
 96 | 		cli.IntFlag{"namespace-pid, ns-pid", 0, "target namespace pid", false},
 97 | 		cli.StringFlag{"namespace-path, ns-path", "", "target namespace path", false},
 98 | 		cli.StringFlag{"path, p", "", "path to a etcd dir", false},
 99 | 		cli.StringFlag{"addr, a", "127.0.0.1:8080", "target address inside the namespace", false},
100 | 		cli.StringFlag{"peers, C", "http://127.0.0.1:4001", "a comma seperated list of machine addresses in the etcd cluster", false},
101 | 	}
102 | 	app.Action = proxy
103 | 	app.Run(os.Args)
104 | }
105 | 


--------------------------------------------------------------------------------
/third_party.go:
--------------------------------------------------------------------------------
  1 | // +build ignore
  2 | 
  3 | /*
  4 | Copyright 2013 Brandon Philips
  5 | 
  6 | Licensed under the Apache License, Version 2.0 (the "License");
  7 | you may not use this file except in compliance with the License.
  8 | You may obtain a copy of the License at
  9 | 
 10 |      http://www.apache.org/licenses/LICENSE-2.0
 11 | 
 12 | Unless required by applicable law or agreed to in writing, software
 13 | distributed under the License is distributed on an "AS IS" BASIS,
 14 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | See the License for the specific language governing permissions and
 16 | limitations under the License.
 17 | */
 18 | 
 19 | // This program builds a project and is a copy of third_party.go. See
 20 | // github.com/philips/third_party.go
 21 | //
 22 | // $ go run third_party.go
 23 | //
 24 | // See the README file for more details.
 25 | package main
 26 | 
 27 | import (
 28 | 	"fmt"
 29 | 	"io"
 30 | 	"io/ioutil"
 31 | 	"log"
 32 | 	"os"
 33 | 	"os/exec"
 34 | 	"path"
 35 | 	"path/filepath"
 36 | 	"strings"
 37 | )
 38 | 
 39 | const (
 40 | 	DefaultThirdParty = "third_party"
 41 | )
 42 | 
 43 | // thirdPartyDir creates a string path to the third_party directory based on
 44 | // the current working directory.
 45 | func thirdPartyDir() string {
 46 | 	root, err := os.Getwd()
 47 | 	if err != nil {
 48 | 		log.Fatalf("Failed to get the current working directory: %v", err)
 49 | 	}
 50 | 	return path.Join(root, DefaultThirdParty)
 51 | }
 52 | 
 53 | func srcDir() string {
 54 | 	return path.Join(thirdPartyDir(), "src")
 55 | }
 56 | 
 57 | // binDir creates a string path to the GOBIN directory based on the current
 58 | // working directory.
 59 | func binDir() string {
 60 | 	root, err := os.Getwd()
 61 | 	if err != nil {
 62 | 		log.Fatalf("Failed to get the current working directory: %v", err)
 63 | 	}
 64 | 	return path.Join(root, "bin")
 65 | }
 66 | 
 67 | // run execs a command like a shell script piping everything to the parent's
 68 | // stderr/stdout and uses the given environment.
 69 | func run(name string, arg ...string) *os.ProcessState {
 70 | 	cmd := exec.Command(name, arg...)
 71 | 
 72 | 	stdout, err := cmd.StdoutPipe()
 73 | 	if err != nil {
 74 | 		fmt.Fprintf(os.Stderr, err.Error())
 75 | 		os.Exit(1)
 76 | 	}
 77 | 	stderr, err := cmd.StderrPipe()
 78 | 	if err != nil {
 79 | 		fmt.Fprintf(os.Stderr, err.Error())
 80 | 		os.Exit(1)
 81 | 	}
 82 | 	err = cmd.Start()
 83 | 	if err != nil {
 84 | 		fmt.Fprintf(os.Stderr, err.Error())
 85 | 		os.Exit(1)
 86 | 	}
 87 | 	go io.Copy(os.Stdout, stdout)
 88 | 	go io.Copy(os.Stderr, stderr)
 89 | 	cmd.Wait()
 90 | 
 91 | 	return cmd.ProcessState
 92 | }
 93 | 
 94 | // setupProject does the initial setup of the third_party src directory
 95 | // including setting up the symlink to the cwd from the src directory.
 96 | func setupProject(pkg string) {
 97 | 	root, err := os.Getwd()
 98 | 	if err != nil {
 99 | 		log.Fatalf("Failed to get the current working directory: %v", err)
100 | 	}
101 | 
102 | 	src := path.Join(thirdPartyDir(), "src", pkg)
103 | 	srcdir := path.Dir(src)
104 | 
105 | 	os.MkdirAll(srcdir, 0755)
106 | 
107 | 	rel, err := filepath.Rel(srcdir, root)
108 | 	if err != nil {
109 | 		log.Fatalf("creating relative third party path: %v", err)
110 | 	}
111 | 
112 | 	err = os.Symlink(rel, src)
113 | 	if err != nil && os.IsExist(err) == false {
114 | 		log.Fatalf("creating project third party symlink: %v", err)
115 | 	}
116 | }
117 | 
118 | func getVc(root string) versionControl {
119 | 	for _, v := range []string{".git", ".hg"} {
120 | 		r := path.Join(root, v)
121 | 		info, err := os.Stat(r)
122 | 
123 | 		if err != nil || !info.IsDir() {
124 | 			continue
125 | 		}
126 | 
127 | 		base := path.Base(r)
128 | 		switch base {
129 | 		case ".git":
130 | 			return vcGit(r)
131 | 		case ".hg":
132 | 			return vcHg(r)
133 | 		}
134 | 	}
135 | 	return new(vcNoop)
136 | }
137 | 
138 | type versionControl interface {
139 | 	commit() string
140 | 	update(string) error
141 | }
142 | 
143 | //  Performs noops on all VC operations.
144 | type vcNoop struct{}
145 | 
146 | func (v *vcNoop) commit() string {
147 | 	return ""
148 | }
149 | 
150 | func (v *vcNoop) update(dir string) error {
151 | 	return nil
152 | }
153 | 
154 | type vcHg string
155 | 
156 | // vcHg.commit returns the current HEAD commit hash for a given hg dir.
157 | func (v vcHg) commit() string {
158 | 	out, err := exec.Command("hg", "id", "-i", "-R", string(v)).Output()
159 | 	if err != nil {
160 | 		return ""
161 | 	}
162 | 	return string(out)
163 | }
164 | 
165 | // vcHg.udpate updates the given hg dir to ref.
166 | func (v vcHg) update(ref string) error {
167 | 	_, err := exec.Command("hg",
168 | 		"update",
169 | 		"-r", ref,
170 | 		"-R", string(v),
171 | 		"--cwd", path.Dir(string(v)),
172 | 	).Output()
173 | 	if err != nil {
174 | 		return err
175 | 	}
176 | 	return nil
177 | }
178 | 
179 | type vcGit string
180 | 
181 | // vcGit.commit returns the current HEAD commit hash for a given git dir.
182 | func (v vcGit) commit() string {
183 | 	out, err := exec.Command("git", "--git-dir="+string(v), "rev-parse", "HEAD").Output()
184 | 	if err != nil {
185 | 		return ""
186 | 	}
187 | 	return string(out)
188 | }
189 | 
190 | // vcHg.udpate updates the given git dir to ref.
191 | func (v vcGit) update(ref string) error {
192 | 	_, err := exec.Command("git",
193 | 		"--work-tree="+path.Dir(string(v)),
194 | 		"--git-dir="+string(v),
195 | 		"reset", "--hard", ref,
196 | 	).Output()
197 | 	if err != nil {
198 | 		return err
199 | 	}
200 | 	return nil
201 | }
202 | 
203 | // commit grabs the commit id from hg or git as a string.
204 | func commit(dir string) string {
205 | 	return getVc(dir).commit()
206 | }
207 | 
208 | // removeVcs removes a .git or .hg directory from the given root if it exists.
209 | func removeVcs(root string) (bool, string) {
210 | 	for _, v := range []string{".git", ".hg"} {
211 | 		r := path.Join(root, v)
212 | 		info, err := os.Stat(r)
213 | 
214 | 		if err != nil {
215 | 			continue
216 | 		}
217 | 
218 | 		// We didn't find it, next!
219 | 		if info.IsDir() == false {
220 | 			continue
221 | 		}
222 | 
223 | 		// We found it, grab the commit and remove the directory
224 | 		c := commit(root)
225 | 		err = os.RemoveAll(r)
226 | 		if err != nil {
227 | 			log.Fatalf("removeVcs: %v", err)
228 | 		}
229 | 		return true, c
230 | 	}
231 | 
232 | 	return false, ""
233 | }
234 | 
235 | // bump takes care of grabbing a package, getting the package git hash and
236 | // removing all of the version control stuff.
237 | func bump(pkg, version string) {
238 | 	tpd := thirdPartyDir()
239 | 
240 | 	temp, err := ioutil.TempDir(tpd, "bump")
241 | 	if err != nil {
242 | 		log.Fatalf("bump: %v", err)
243 | 	}
244 | 	defer os.RemoveAll(temp)
245 | 
246 | 	os.Setenv("GOPATH", temp)
247 | 	run("go", "get", "-u", "-d", pkg)
248 | 
249 | 	for {
250 | 		root := path.Join(temp, "src", pkg) // the temp installation root
251 | 		home := path.Join(tpd, "src", pkg)  // where the package will end up
252 | 
253 | 		if version != "" {
254 | 			err := getVc(root).update(version)
255 | 			if err != nil {
256 | 				log.Fatalf("bump: %v", err)
257 | 			}
258 | 		}
259 | 
260 | 		ok, c := removeVcs(root)
261 | 		if ok {
262 | 			// Create the path leading up to the package
263 | 			err := os.MkdirAll(path.Dir(home), 0755)
264 | 			if err != nil {
265 | 				log.Fatalf("bump: %v", err)
266 | 			}
267 | 
268 | 			// Remove anything that might have been there
269 | 			err = os.RemoveAll(home)
270 | 			if err != nil {
271 | 				log.Fatalf("bump: %v", err)
272 | 			}
273 | 
274 | 			// Finally move the package
275 | 			err = os.Rename(root, home)
276 | 			if err != nil {
277 | 				log.Fatalf("bump: %v", err)
278 | 			}
279 | 
280 | 			fmt.Printf("%s %s\n", pkg, strings.TrimSpace(c))
281 | 			break
282 | 		}
283 | 
284 | 		// Pop off and try to find this directory!
285 | 		pkg = path.Dir(pkg)
286 | 		if pkg == "." {
287 | 			return
288 | 		}
289 | 	}
290 | }
291 | 
292 | // validPkg uses go list to decide if the given path is a valid go package.
293 | // This is used by the bumpAll walk to bump all of the existing packages.
294 | func validPkg(pkg string) bool {
295 | 	env := append(os.Environ(),
296 | 	)
297 | 	cmd := exec.Command("go", "list", pkg)
298 | 	cmd.Env = env
299 | 
300 | 	out, err := cmd.Output()
301 | 	if err != nil {
302 | 		return false
303 | 	}
304 | 
305 | 	if pkg == strings.TrimSpace(string(out)) {
306 | 		return true
307 | 	}
308 | 
309 | 	return false
310 | }
311 | 
312 | // bumpWalk walks the third_party directory and bumps all of the packages that it finds.
313 | func bumpWalk(path string, info os.FileInfo, err error) error {
314 | 	if err != nil {
315 | 		return nil
316 | 	}
317 | 
318 | 	// go packages are always directories
319 | 	if info.IsDir() == false {
320 | 		return nil
321 | 	}
322 | 
323 | 	parts := strings.Split(path, srcDir()+"/")
324 | 	if len(parts) == 1 {
325 | 		return nil
326 | 	}
327 | 
328 | 	pkg := parts[1]
329 | 
330 | 	if validPkg(pkg) == false {
331 | 		return nil
332 | 	}
333 | 
334 | 	bump(pkg, "")
335 | 
336 | 	return nil
337 | }
338 | 
339 | func bumpAll() {
340 | 	err := filepath.Walk(srcDir(), bumpWalk)
341 | 	if err != nil {
342 | 		log.Fatalf(err.Error())
343 | 	}
344 | }
345 | 
346 | func main() {
347 | 	log.SetFlags(0)
348 | 
349 | 	// third_party manages GOPATH, no one else
350 | 	os.Setenv("GOPATH", thirdPartyDir())
351 | 	os.Setenv("GOBIN", binDir())
352 | 
353 | 	if len(os.Args) <= 1 {
354 | 		log.Fatalf("No command")
355 | 	}
356 | 
357 | 	cmd := os.Args[1]
358 | 
359 | 	if cmd == "setup" && len(os.Args) > 2 {
360 | 		setupProject(os.Args[2])
361 | 		return
362 | 	}
363 | 
364 | 	if cmd == "bump" && len(os.Args) > 2 {
365 | 		ref := ""
366 | 		if len(os.Args) > 3 {
367 | 			ref = os.Args[3]
368 | 		}
369 | 
370 | 		bump(os.Args[2], ref)
371 | 		return
372 | 	}
373 | 
374 | 	if cmd == "bump-all" && len(os.Args) > 1 {
375 | 		bumpAll()
376 | 		return
377 | 	}
378 | 
379 | 	ps := run("go", os.Args[1:]...)
380 | 
381 | 	if ps.Success() == false {
382 | 		os.Exit(1)
383 | 	}
384 | }
385 | 


--------------------------------------------------------------------------------
/third_party/src/bitbucket.org/kardianos/osext/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2012 Daniel Theophanes
 2 | 
 3 | This software is provided 'as-is', without any express or implied
 4 | warranty. In no event will the authors be held liable for any damages
 5 | arising from the use of this software.
 6 | 
 7 | Permission is granted to anyone to use this software for any purpose,
 8 | including commercial applications, and to alter it and redistribute it
 9 | freely, subject to the following restrictions:
10 | 
11 |    1. The origin of this software must not be misrepresented; you must not
12 |    claim that you wrote the original software. If you use this software
13 |    in a product, an acknowledgment in the product documentation would be
14 |    appreciated but is not required.
15 | 
16 |    2. Altered source versions must be plainly marked as such, and must not be
17 |    misrepresented as being the original software.
18 | 
19 |    3. This notice may not be removed or altered from any source
20 |    distribution.
21 | 


--------------------------------------------------------------------------------
/third_party/src/bitbucket.org/kardianos/osext/osext.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Extensions to the standard "os" package.
 6 | package osext
 7 | 
 8 | import "path/filepath"
 9 | 
10 | // Executable returns an absolute path that can be used to
11 | // re-invoke the current program.
12 | // It may not be valid after the current program exits.
13 | func Executable() (string, error) {
14 | 	p, err := executable()
15 | 	return filepath.Clean(p), err
16 | }
17 | 
18 | // Returns same path as Executable, returns just the folder
19 | // path. Excludes the executable name.
20 | func ExecutableFolder() (string, error) {
21 | 	p, err := Executable()
22 | 	if err != nil {
23 | 		return "", err
24 | 	}
25 | 	folder, _ := filepath.Split(p)
26 | 	return folder, nil
27 | }
28 | 
29 | // Depricated. Same as Executable().
30 | func GetExePath() (exePath string, err error) {
31 | 	return Executable()
32 | }
33 | 


--------------------------------------------------------------------------------
/third_party/src/bitbucket.org/kardianos/osext/osext_plan9.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package osext
 6 | 
 7 | import "syscall"
 8 | 
 9 | func executable() (string, error) {
10 | 	f, err := Open("/proc/" + itoa(Getpid()) + "/text")
11 | 	if err != nil {
12 | 		return "", err
13 | 	}
14 | 	defer f.Close()
15 | 	return syscall.Fd2path(int(f.Fd()))
16 | }
17 | 


--------------------------------------------------------------------------------
/third_party/src/bitbucket.org/kardianos/osext/osext_procfs.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux netbsd openbsd
 6 | 
 7 | package osext
 8 | 
 9 | import (
10 | 	"errors"
11 | 	"os"
12 | 	"runtime"
13 | )
14 | 
15 | func executable() (string, error) {
16 | 	switch runtime.GOOS {
17 | 	case "linux":
18 | 		return os.Readlink("/proc/self/exe")
19 | 	case "netbsd":
20 | 		return os.Readlink("/proc/curproc/exe")
21 | 	case "openbsd":
22 | 		return os.Readlink("/proc/curproc/file")
23 | 	}
24 | 	return "", errors.New("ExecPath not implemented for " + runtime.GOOS)
25 | }
26 | 


--------------------------------------------------------------------------------
/third_party/src/bitbucket.org/kardianos/osext/osext_sysctl.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build darwin freebsd
 6 | 
 7 | package osext
 8 | 
 9 | import (
10 | 	"os"
11 | 	"path/filepath"
12 | 	"runtime"
13 | 	"syscall"
14 | 	"unsafe"
15 | )
16 | 
17 | var startUpcwd, getwdError = os.Getwd()
18 | 
19 | func executable() (string, error) {
20 | 	var mib [4]int32
21 | 	switch runtime.GOOS {
22 | 	case "freebsd":
23 | 		mib = [4]int32{1 /* CTL_KERN */, 14 /* KERN_PROC */, 12 /* KERN_PROC_PATHNAME */, -1}
24 | 	case "darwin":
25 | 		mib = [4]int32{1 /* CTL_KERN */, 38 /* KERN_PROCARGS */, int32(os.Getpid()), -1}
26 | 	}
27 | 
28 | 	n := uintptr(0)
29 | 	// get length
30 | 	_, _, err := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 4, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
31 | 	if err != 0 {
32 | 		return "", err
33 | 	}
34 | 	if n == 0 { // shouldn't happen
35 | 		return "", nil
36 | 	}
37 | 	buf := make([]byte, n)
38 | 	_, _, err = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 4, uintptr(unsafe.Pointer(&buf[0])), uintptr(unsafe.Pointer(&n)), 0, 0)
39 | 	if err != 0 {
40 | 		return "", err
41 | 	}
42 | 	if n == 0 { // shouldn't happen
43 | 		return "", nil
44 | 	}
45 | 	for i, v := range buf {
46 | 		if v == 0 {
47 | 			buf = buf[:i]
48 | 			break
49 | 		}
50 | 	}
51 | 	var strpath string
52 | 	if buf[0] != '/' {
53 | 		var e error
54 | 		if strpath, e = getAbs(buf); e != nil {
55 | 			return strpath, e
56 | 		}
57 | 	} else {
58 | 		strpath = string(buf)
59 | 	}
60 | 	// darwin KERN_PROCARGS may return the path to a symlink rather than the
61 | 	// actual executable
62 | 	if runtime.GOOS == "darwin" {
63 | 		if strpath, err := filepath.EvalSymlinks(strpath); err != nil {
64 | 			return strpath, err
65 | 		}
66 | 	}
67 | 	return strpath, nil
68 | }
69 | 
70 | func getAbs(buf []byte) (string, error) {
71 | 	if getwdError != nil {
72 | 		return string(buf), getwdError
73 | 	} else {
74 | 		if buf[0] == '.' {
75 | 			buf = buf[1:]
76 | 		}
77 | 		if startUpcwd[len(startUpcwd)-1] != '/' && buf[0] != '/' {
78 | 			return startUpcwd + "/" + string(buf), nil
79 | 		}
80 | 		return startUpcwd + string(buf), nil
81 | 	}
82 | }
83 | 


--------------------------------------------------------------------------------
/third_party/src/bitbucket.org/kardianos/osext/osext_test.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build darwin linux freebsd netbsd windows
 6 | 
 7 | package osext
 8 | 
 9 | import (
10 | 	"fmt"
11 | 	"os"
12 | 	oexec "os/exec"
13 | 	"path/filepath"
14 | 	"runtime"
15 | 	"testing"
16 | )
17 | 
18 | const execPath_EnvVar = "OSTEST_OUTPUT_EXECPATH"
19 | 
20 | func TestExecPath(t *testing.T) {
21 | 	ep, err := Executable()
22 | 	if err != nil {
23 | 		t.Fatalf("ExecPath failed: %v", err)
24 | 	}
25 | 	// we want fn to be of the form "dir/prog"
26 | 	dir := filepath.Dir(filepath.Dir(ep))
27 | 	fn, err := filepath.Rel(dir, ep)
28 | 	if err != nil {
29 | 		t.Fatalf("filepath.Rel: %v", err)
30 | 	}
31 | 	cmd := &oexec.Cmd{}
32 | 	// make child start with a relative program path
33 | 	cmd.Dir = dir
34 | 	cmd.Path = fn
35 | 	// forge argv[0] for child, so that we can verify we could correctly
36 | 	// get real path of the executable without influenced by argv[0].
37 | 	cmd.Args = []string{"-", "-test.run=XXXX"}
38 | 	cmd.Env = []string{fmt.Sprintf("%s=1", execPath_EnvVar)}
39 | 	out, err := cmd.CombinedOutput()
40 | 	if err != nil {
41 | 		t.Fatalf("exec(self) failed: %v", err)
42 | 	}
43 | 	outs := string(out)
44 | 	if !filepath.IsAbs(outs) {
45 | 		t.Fatalf("Child returned %q, want an absolute path", out)
46 | 	}
47 | 	if !sameFile(outs, ep) {
48 | 		t.Fatalf("Child returned %q, not the same file as %q", out, ep)
49 | 	}
50 | }
51 | 
52 | func sameFile(fn1, fn2 string) bool {
53 | 	fi1, err := os.Stat(fn1)
54 | 	if err != nil {
55 | 		return false
56 | 	}
57 | 	fi2, err := os.Stat(fn2)
58 | 	if err != nil {
59 | 		return false
60 | 	}
61 | 	return os.SameFile(fi1, fi2)
62 | }
63 | 
64 | func init() {
65 | 	if e := os.Getenv(execPath_EnvVar); e != "" {
66 | 		// first chdir to another path
67 | 		dir := "/"
68 | 		if runtime.GOOS == "windows" {
69 | 			dir = filepath.VolumeName(".")
70 | 		}
71 | 		os.Chdir(dir)
72 | 		if ep, err := Executable(); err != nil {
73 | 			fmt.Fprint(os.Stderr, "ERROR: ", err)
74 | 		} else {
75 | 			fmt.Fprint(os.Stderr, ep)
76 | 		}
77 | 		os.Exit(0)
78 | 	}
79 | }
80 | 


--------------------------------------------------------------------------------
/third_party/src/bitbucket.org/kardianos/osext/osext_windows.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package osext
 6 | 
 7 | import (
 8 | 	"syscall"
 9 | 	"unicode/utf16"
10 | 	"unsafe"
11 | )
12 | 
13 | var (
14 | 	kernel                = syscall.MustLoadDLL("kernel32.dll")
15 | 	getModuleFileNameProc = kernel.MustFindProc("GetModuleFileNameW")
16 | )
17 | 
18 | // GetModuleFileName() with hModule = NULL
19 | func executable() (exePath string, err error) {
20 | 	return getModuleFileName()
21 | }
22 | 
23 | func getModuleFileName() (string, error) {
24 | 	var n uint32
25 | 	b := make([]uint16, syscall.MAX_PATH)
26 | 	size := uint32(len(b))
27 | 
28 | 	r0, _, e1 := getModuleFileNameProc.Call(0, uintptr(unsafe.Pointer(&b[0])), uintptr(size))
29 | 	n = uint32(r0)
30 | 	if n == 0 {
31 | 		return "", e1
32 | 	}
33 | 	return string(utf16.Decode(b[0:n])), nil
34 | }
35 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go: 1.1
3 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2013 Jeremy Saenz
 2 | All Rights Reserved.
 3 | 
 4 | MIT LICENSE
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 7 | this software and associated documentation files (the "Software"), to deal in
 8 | the Software without restriction, including without limitation the rights to
 9 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
10 | the Software, and to permit persons to whom the Software is furnished to do so,
11 | subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
18 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
19 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
20 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/README.md:
--------------------------------------------------------------------------------
  1 | [![Build Status](https://travis-ci.org/codegangsta/cli.png?branch=master)](https://travis-ci.org/codegangsta/cli)
  2 | 
  3 | # cli.go
  4 | cli.go is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
  5 | 
  6 | You can view the API docs here:
  7 | http://godoc.org/github.com/codegangsta/cli
  8 | 
  9 | ## Overview
 10 | Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
 11 | 
 12 | This is where cli.go comes into play. cli.go makes command line programming fun, organized, and expressive!
 13 | 
 14 | ## Installation
 15 | Make sure you have the a working Go environment (go 1.1 is *required*). [See the install instructions](http://golang.org/doc/install.html).
 16 | 
 17 | To install cli.go, simply run:
 18 | ```
 19 | $ go get github.com/codegangsta/cli
 20 | ```
 21 | 
 22 | Make sure your PATH includes to the `$GOPATH/bin` directory so your commands can be easily used:
 23 | ```
 24 | export PATH=$PATH:$GOPATH/bin
 25 | ```
 26 | 
 27 | ## Getting Started
 28 | One of the philosophies behind cli.go is that an API should be playful and full of discovery. So a cli.go app can be as little as one line of code in `main()`. 
 29 | 
 30 | ``` go
 31 | package main
 32 | 
 33 | import (
 34 |   "os"
 35 |   "github.com/codegangsta/cli"
 36 | )
 37 | 
 38 | func main() {
 39 |   cli.NewApp().Run(os.Args)
 40 | }
 41 | ```
 42 | 
 43 | This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
 44 | 
 45 | ``` go
 46 | package main
 47 | 
 48 | import (
 49 |   "os"
 50 |   "github.com/codegangsta/cli"
 51 | )
 52 | 
 53 | func main() {
 54 |   app := cli.NewApp()
 55 |   app.Name = "boom"
 56 |   app.Usage = "make an explosive entrance"
 57 |   app.Action = func(c *cli.Context) {
 58 |     println("boom! I say!")
 59 |   }
 60 |   
 61 |   app.Run(os.Args)
 62 | }
 63 | ```
 64 | 
 65 | Running this already gives you a ton of functionality, plus support for things like subcommands and flags, which are covered below.
 66 | 
 67 | ## Example
 68 | 
 69 | Being a programmer can be a lonely job. Thankfully by the power of automation that is not the case! Let's create a greeter app to fend off our demons of loneliness!
 70 | 
 71 | ``` go
 72 | /* greet.go */
 73 | package main
 74 | 
 75 | import (
 76 |   "os"
 77 |   "github.com/codegangsta/cli"
 78 | )
 79 | 
 80 | func main() {
 81 |   app := cli.NewApp()
 82 |   app.Name = "greet"
 83 |   app.Usage = "fight the loneliness!"
 84 |   app.Action = func(c *cli.Context) {
 85 |     println("Hello friend!")
 86 |   }
 87 |   
 88 |   app.Run(os.Args)
 89 | }
 90 | ```
 91 | 
 92 | Install our command to the `$GOPATH/bin` directory:
 93 | 
 94 | ```
 95 | $ go install
 96 | ```
 97 | 
 98 | Finally run our new command:
 99 | 
100 | ```
101 | $ greet
102 | Hello friend!
103 | ```
104 | 
105 | cli.go also generates some bitchass help text:
106 | ```
107 | $ greet help
108 | NAME:
109 |     greet - fight the loneliness!
110 | 
111 | USAGE:
112 |     greet [global options] command [command options] [arguments...]
113 | 
114 | VERSION:
115 |     0.0.0
116 | 
117 | COMMANDS:
118 |     help, h  Shows a list of commands or help for one command
119 | 
120 | GLOBAL OPTIONS
121 |     --version	Shows version information
122 | ```
123 | 
124 | ### Arguments
125 | You can lookup arguments by calling the `Args` function on cli.Context.
126 | 
127 | ``` go
128 | ...
129 | app.Action = func(c *cli.Context) {
130 |   println("Hello", c.Args()[0])
131 | }
132 | ...
133 | ```
134 | 
135 | ### Flags
136 | Setting and querying flags is simple.
137 | ``` go
138 | ...
139 | app.Flags = []cli.Flag {
140 |   cli.StringFlag{"lang", "english", "language for the greeting"},
141 | }
142 | app.Action = func(c *cli.Context) {
143 |   name := "someone"
144 |   if len(c.Args()) > 0 {
145 |     name = c.Args()[0]
146 |   }
147 |   if c.String("lang") == "spanish" {
148 |     println("Hola", name)
149 |   } else {
150 |     println("Hello", name)
151 |   }
152 | }
153 | ...
154 | ```
155 | 
156 | #### Alternate Names
157 | 
158 | You can set alternate (or short) names for flags by providing a comma-delimited list for the Name. e.g.
159 | 
160 | ``` go
161 | app.Flags = []cli.Flag {
162 |   cli.StringFlag{"lang, l", "english", "language for the greeting"},
163 | }
164 | ```
165 | 
166 | That flag can then be set with `--lang spanish` or `-l spanish`. Note that giving two different forms of the same flag in the same command invocation is an error.
167 | 
168 | ### Subcommands
169 | 
170 | Subcommands can be defined for a more git-like command line app.
171 | ```go
172 | ...
173 | app.Commands = []cli.Command{
174 |   {
175 |     Name:      "add",
176 |     ShortName: "a",
177 |     Usage:     "add a task to the list",
178 |     Action: func(c *cli.Context) {
179 |       println("added task: ", c.FirstArg())
180 |     },
181 |   },
182 |   {
183 |     Name:      "complete",
184 |     ShortName: "c",
185 |     Usage:     "complete a task on the list",
186 |     Action: func(c *cli.Context) {
187 |       println("completed task: ", c.FirstArg())
188 |     },
189 |   },
190 | }
191 | ...
192 | ```
193 | 
194 | ## About
195 | cli.go is written by none other than the [Code Gangsta](http://codegangsta.io)
196 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/app.go:
--------------------------------------------------------------------------------
  1 | package cli
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"io/ioutil"
  6 | 	"os"
  7 | 	"time"
  8 | )
  9 | 
 10 | // App is the main structure of a cli application. It is recomended that
 11 | // and app be created with the cli.NewApp() function
 12 | type App struct {
 13 | 	// The name of the program. Defaults to os.Args[0]
 14 | 	Name string
 15 | 	// Description of the program.
 16 | 	Usage string
 17 | 	// Version of the program
 18 | 	Version string
 19 | 	// List of commands to execute
 20 | 	Commands []Command
 21 | 	// List of flags to parse
 22 | 	Flags []Flag
 23 | 	// The action to execute when no subcommands are specified
 24 | 	Action func(context *Context)
 25 | 	// Compilation date
 26 | 	Compiled time.Time
 27 | 	// Author
 28 | 	Author string
 29 | 	// Author e-mail
 30 | 	Email string
 31 | }
 32 | 
 33 | // Tries to find out when this binary was compiled.
 34 | // Returns the current time if it fails to find it.
 35 | func compileTime() time.Time {
 36 | 	info, err := os.Stat(os.Args[0])
 37 | 	if err != nil {
 38 | 		return time.Now()
 39 | 	}
 40 | 	return info.ModTime()
 41 | }
 42 | 
 43 | // Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
 44 | func NewApp() *App {
 45 | 	return &App{
 46 | 		Name:     os.Args[0],
 47 | 		Usage:    "A new cli application",
 48 | 		Version:  "0.0.0",
 49 | 		Action:   helpCommand.Action,
 50 | 		Compiled: compileTime(),
 51 | 		Author:   "Author",
 52 | 		Email:    "unknown@email",
 53 | 	}
 54 | }
 55 | 
 56 | // Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
 57 | func (a *App) Run(arguments []string) error {
 58 | 	// append help to commands
 59 | 	if a.Command(helpCommand.Name) == nil {
 60 | 		a.Commands = append(a.Commands, helpCommand)
 61 | 	}
 62 | 
 63 | 	//append version/help flags
 64 | 	a.appendFlag(BoolFlag{"version, v", "print the version"})
 65 | 	a.appendFlag(BoolFlag{"help, h", "show help"})
 66 | 
 67 | 	// parse flags
 68 | 	set := flagSet(a.Name, a.Flags)
 69 | 	set.SetOutput(ioutil.Discard)
 70 | 	err := set.Parse(arguments[1:])
 71 | 	nerr := normalizeFlags(a.Flags, set)
 72 | 	if nerr != nil {
 73 | 		fmt.Println(nerr)
 74 | 		context := NewContext(a, set, set)
 75 | 		ShowAppHelp(context)
 76 | 		fmt.Println("")
 77 | 		return nerr
 78 | 	}
 79 | 	context := NewContext(a, set, set)
 80 | 
 81 | 	if err != nil {
 82 | 		fmt.Printf("Incorrect Usage.\n\n")
 83 | 		ShowAppHelp(context)
 84 | 		fmt.Println("")
 85 | 		return err
 86 | 	}
 87 | 
 88 | 	if checkHelp(context) {
 89 | 		return nil
 90 | 	}
 91 | 
 92 | 	if checkVersion(context) {
 93 | 		return nil
 94 | 	}
 95 | 
 96 | 	args := context.Args()
 97 | 	if args.Present() {
 98 | 		name := args.First()
 99 | 		c := a.Command(name)
100 | 		if c != nil {
101 | 			return c.Run(context)
102 | 		}
103 | 	}
104 | 
105 | 	// Run default Action
106 | 	a.Action(context)
107 | 	return nil
108 | }
109 | 
110 | // Returns the named command on App. Returns nil if the command does not exist
111 | func (a *App) Command(name string) *Command {
112 | 	for _, c := range a.Commands {
113 | 		if c.HasName(name) {
114 | 			return &c
115 | 		}
116 | 	}
117 | 
118 | 	return nil
119 | }
120 | 
121 | func (a *App) hasFlag(flag Flag) bool {
122 | 	for _, f := range a.Flags {
123 | 		if flag == f {
124 | 			return true
125 | 		}
126 | 	}
127 | 
128 | 	return false
129 | }
130 | 
131 | func (a *App) appendFlag(flag Flag) {
132 | 	if !a.hasFlag(flag) {
133 | 		a.Flags = append(a.Flags, flag)
134 | 	}
135 | }
136 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/app_test.go:
--------------------------------------------------------------------------------
  1 | package cli_test
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"github.com/codegangsta/cli"
  6 | 	"os"
  7 | 	"testing"
  8 | )
  9 | 
 10 | func ExampleApp() {
 11 | 	// set args for examples sake
 12 | 	os.Args = []string{"greet", "--name", "Jeremy"}
 13 | 
 14 | 	app := cli.NewApp()
 15 | 	app.Name = "greet"
 16 | 	app.Flags = []cli.Flag{
 17 | 		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
 18 | 	}
 19 | 	app.Action = func(c *cli.Context) {
 20 | 		fmt.Printf("Hello %v\n", c.String("name"))
 21 | 	}
 22 | 	app.Run(os.Args)
 23 | 	// Output:
 24 | 	// Hello Jeremy
 25 | }
 26 | 
 27 | func TestApp_Run(t *testing.T) {
 28 | 	s := ""
 29 | 
 30 | 	app := cli.NewApp()
 31 | 	app.Action = func(c *cli.Context) {
 32 | 		s = s + c.Args().First()
 33 | 	}
 34 | 
 35 | 	err := app.Run([]string{"command", "foo"})
 36 | 	expect(t, err, nil)
 37 | 	err = app.Run([]string{"command", "bar"})
 38 | 	expect(t, err, nil)
 39 | 	expect(t, s, "foobar")
 40 | }
 41 | 
 42 | var commandAppTests = []struct {
 43 | 	name     string
 44 | 	expected bool
 45 | }{
 46 | 	{"foobar", true},
 47 | 	{"batbaz", true},
 48 | 	{"b", true},
 49 | 	{"f", true},
 50 | 	{"bat", false},
 51 | 	{"nothing", false},
 52 | }
 53 | 
 54 | func TestApp_Command(t *testing.T) {
 55 | 	app := cli.NewApp()
 56 | 	fooCommand := cli.Command{Name: "foobar", ShortName: "f"}
 57 | 	batCommand := cli.Command{Name: "batbaz", ShortName: "b"}
 58 | 	app.Commands = []cli.Command{
 59 | 		fooCommand,
 60 | 		batCommand,
 61 | 	}
 62 | 
 63 | 	for _, test := range commandAppTests {
 64 | 		expect(t, app.Command(test.name) != nil, test.expected)
 65 | 	}
 66 | }
 67 | 
 68 | func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
 69 | 	var parsedOption, firstArg string
 70 | 
 71 | 	app := cli.NewApp()
 72 | 	command := cli.Command{
 73 | 		Name: "cmd",
 74 | 		Flags: []cli.Flag{
 75 | 			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
 76 | 		},
 77 | 		Action: func(c *cli.Context) {
 78 | 			parsedOption = c.String("option")
 79 | 			firstArg = c.Args().First()
 80 | 		},
 81 | 	}
 82 | 	app.Commands = []cli.Command{command}
 83 | 
 84 | 	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
 85 | 
 86 | 	expect(t, parsedOption, "my-option")
 87 | 	expect(t, firstArg, "my-arg")
 88 | }
 89 | 
 90 | func TestApp_Float64Flag(t *testing.T) {
 91 | 	var meters float64
 92 | 
 93 | 	app := cli.NewApp()
 94 | 	app.Flags = []cli.Flag{
 95 | 		cli.Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
 96 | 	}
 97 | 	app.Action = func(c *cli.Context) {
 98 | 		meters = c.Float64("height")
 99 | 	}
100 | 
101 | 	app.Run([]string{"", "--height", "1.93"})
102 | 	expect(t, meters, 1.93)
103 | }
104 | 
105 | func TestApp_ParseSliceFlags(t *testing.T) {
106 | 	var parsedOption, firstArg string
107 | 	var parsedIntSlice []int
108 | 	var parsedStringSlice []string
109 | 
110 | 	app := cli.NewApp()
111 | 	command := cli.Command{
112 | 		Name: "cmd",
113 | 		Flags: []cli.Flag{
114 | 			cli.IntSliceFlag{Name: "p", Value: &cli.IntSlice{}, Usage: "set one or more ip addr"},
115 | 			cli.StringSliceFlag{Name: "ip", Value: &cli.StringSlice{}, Usage: "set one or more ports to open"},
116 | 		},
117 | 		Action: func(c *cli.Context) {
118 | 			parsedIntSlice = c.IntSlice("p")
119 | 			parsedStringSlice = c.StringSlice("ip")
120 | 			parsedOption = c.String("option")
121 | 			firstArg = c.Args().First()
122 | 		},
123 | 	}
124 | 	app.Commands = []cli.Command{command}
125 | 
126 | 	app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
127 | 
128 | 	IntsEquals := func(a, b []int) bool {
129 | 		if len(a) != len(b) {
130 | 			return false
131 | 		}
132 | 		for i, v := range a {
133 | 			if v != b[i] {
134 | 				return false
135 | 			}
136 | 		}
137 | 		return true
138 | 	}
139 | 
140 | 	StrsEquals := func(a, b []string) bool {
141 | 		if len(a) != len(b) {
142 | 			return false
143 | 		}
144 | 		for i, v := range a {
145 | 			if v != b[i] {
146 | 				return false
147 | 			}
148 | 		}
149 | 		return true
150 | 	}
151 | 	var expectedIntSlice = []int{22, 80}
152 | 	var expectedStringSlice = []string{"8.8.8.8", "8.8.4.4"}
153 | 
154 | 	if !IntsEquals(parsedIntSlice, expectedIntSlice) {
155 | 		t.Errorf("%s does not match %s", parsedIntSlice, expectedIntSlice)
156 | 	}
157 | 
158 | 	if !StrsEquals(parsedStringSlice, expectedStringSlice) {
159 | 		t.Errorf("%s does not match %s", parsedStringSlice, expectedStringSlice)
160 | 	}
161 | }
162 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/cli.go:
--------------------------------------------------------------------------------
 1 | // Package cli provides a minimal framework for creating and organizing command line
 2 | // Go applications. cli is designed to be easy to understand and write, the most simple
 3 | // cli application can be written as follows:
 4 | //   func main() {
 5 | //     cli.NewApp().Run(os.Args)
 6 | //   }
 7 | //
 8 | // Of course this application does not do much, so let's make this an actual application:
 9 | //   func main() {
10 | //     app := cli.NewApp()
11 | //     app.Name = "greet"
12 | //     app.Usage = "say a greeting"
13 | //     app.Action = func(c *cli.Context) {
14 | //       println("Greetings")
15 | //     }
16 | //
17 | //     app.Run(os.Args)
18 | //   }
19 | package cli
20 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/cli_test.go:
--------------------------------------------------------------------------------
 1 | package cli_test
 2 | 
 3 | import (
 4 | 	"github.com/codegangsta/cli"
 5 | 	"os"
 6 | )
 7 | 
 8 | func Example() {
 9 | 	app := cli.NewApp()
10 | 	app.Name = "todo"
11 | 	app.Usage = "task list on the command line"
12 | 	app.Commands = []cli.Command{
13 | 		{
14 | 			Name:      "add",
15 | 			ShortName: "a",
16 | 			Usage:     "add a task to the list",
17 | 			Action: func(c *cli.Context) {
18 | 				println("added task: ", c.Args().First())
19 | 			},
20 | 		},
21 | 		{
22 | 			Name:      "complete",
23 | 			ShortName: "c",
24 | 			Usage:     "complete a task on the list",
25 | 			Action: func(c *cli.Context) {
26 | 				println("completed task: ", c.Args().First())
27 | 			},
28 | 		},
29 | 	}
30 | 
31 | 	app.Run(os.Args)
32 | }
33 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/command.go:
--------------------------------------------------------------------------------
 1 | package cli
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"io/ioutil"
 6 | 	"strings"
 7 | )
 8 | 
 9 | // Command is a subcommand for a cli.App.
10 | type Command struct {
11 | 	// The name of the command
12 | 	Name string
13 | 	// short name of the command. Typically one character
14 | 	ShortName string
15 | 	// A short description of the usage of this command
16 | 	Usage string
17 | 	// A longer explaination of how the command works
18 | 	Description string
19 | 	// The function to call when this command is invoked
20 | 	Action func(context *Context)
21 | 	// List of flags to parse
22 | 	Flags []Flag
23 | }
24 | 
25 | // Invokes the command given the context, parses ctx.Args() to generate command-specific flags
26 | func (c Command) Run(ctx *Context) error {
27 | 	// append help to flags
28 | 	c.Flags = append(
29 | 		c.Flags,
30 | 		BoolFlag{"help, h", "show help"},
31 | 	)
32 | 
33 | 	set := flagSet(c.Name, c.Flags)
34 | 	set.SetOutput(ioutil.Discard)
35 | 
36 | 	firstFlagIndex := -1
37 | 	for index, arg := range ctx.Args() {
38 | 		if strings.HasPrefix(arg, "-") {
39 | 			firstFlagIndex = index
40 | 			break
41 | 		}
42 | 	}
43 | 
44 | 	var err error
45 | 	if firstFlagIndex > -1 {
46 | 		args := ctx.Args()
47 | 		regularArgs := args[1:firstFlagIndex]
48 | 		flagArgs := args[firstFlagIndex:]
49 | 		err = set.Parse(append(flagArgs, regularArgs...))
50 | 	} else {
51 | 		err = set.Parse(ctx.Args().Tail())
52 | 	}
53 | 
54 | 	if err != nil {
55 | 		fmt.Printf("Incorrect Usage.\n\n")
56 | 		ShowCommandHelp(ctx, c.Name)
57 | 		fmt.Println("")
58 | 		return err
59 | 	}
60 | 
61 | 	nerr := normalizeFlags(c.Flags, set)
62 | 	if nerr != nil {
63 | 		fmt.Println(nerr)
64 | 		fmt.Println("")
65 | 		ShowCommandHelp(ctx, c.Name)
66 | 		fmt.Println("")
67 | 		return nerr
68 | 	}
69 | 	context := NewContext(ctx.App, set, ctx.globalSet)
70 | 	if checkCommandHelp(context, c.Name) {
71 | 		return nil
72 | 	}
73 | 	c.Action(context)
74 | 	return nil
75 | }
76 | 
77 | // Returns true if Command.Name or Command.ShortName matches given name
78 | func (c Command) HasName(name string) bool {
79 | 	return c.Name == name || c.ShortName == name
80 | }
81 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/context.go:
--------------------------------------------------------------------------------
  1 | package cli
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"flag"
  6 | 	"strconv"
  7 | 	"strings"
  8 | )
  9 | 
 10 | // Context is a type that is passed through to
 11 | // each Handler action in a cli application. Context
 12 | // can be used to retrieve context-specific Args and
 13 | // parsed command-line options.
 14 | type Context struct {
 15 | 	App       *App
 16 | 	flagSet   *flag.FlagSet
 17 | 	globalSet *flag.FlagSet
 18 | 	setFlags  map[string]bool
 19 | }
 20 | 
 21 | // Creates a new context. For use in when invoking an App or Command action.
 22 | func NewContext(app *App, set *flag.FlagSet, globalSet *flag.FlagSet) *Context {
 23 | 	return &Context{app, set, globalSet, nil}
 24 | }
 25 | 
 26 | // Looks up the value of a local int flag, returns 0 if no int flag exists
 27 | func (c *Context) Int(name string) int {
 28 | 	return lookupInt(name, c.flagSet)
 29 | }
 30 | 
 31 | // Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
 32 | func (c *Context) Float64(name string) float64 {
 33 | 	return lookupFloat64(name, c.flagSet)
 34 | }
 35 | 
 36 | // Looks up the value of a local bool flag, returns false if no bool flag exists
 37 | func (c *Context) Bool(name string) bool {
 38 | 	return lookupBool(name, c.flagSet)
 39 | }
 40 | 
 41 | // Looks up the value of a local string flag, returns "" if no string flag exists
 42 | func (c *Context) String(name string) string {
 43 | 	return lookupString(name, c.flagSet)
 44 | }
 45 | 
 46 | // Looks up the value of a local string slice flag, returns nil if no string slice flag exists
 47 | func (c *Context) StringSlice(name string) []string {
 48 | 	return lookupStringSlice(name, c.flagSet)
 49 | }
 50 | 
 51 | // Looks up the value of a local int slice flag, returns nil if no int slice flag exists
 52 | func (c *Context) IntSlice(name string) []int {
 53 | 	return lookupIntSlice(name, c.flagSet)
 54 | }
 55 | 
 56 | // Looks up the value of a global int flag, returns 0 if no int flag exists
 57 | func (c *Context) GlobalInt(name string) int {
 58 | 	return lookupInt(name, c.globalSet)
 59 | }
 60 | 
 61 | // Looks up the value of a global bool flag, returns false if no bool flag exists
 62 | func (c *Context) GlobalBool(name string) bool {
 63 | 	return lookupBool(name, c.globalSet)
 64 | }
 65 | 
 66 | // Looks up the value of a global string flag, returns "" if no string flag exists
 67 | func (c *Context) GlobalString(name string) string {
 68 | 	return lookupString(name, c.globalSet)
 69 | }
 70 | 
 71 | // Looks up the value of a global string slice flag, returns nil if no string slice flag exists
 72 | func (c *Context) GlobalStringSlice(name string) []string {
 73 | 	return lookupStringSlice(name, c.globalSet)
 74 | }
 75 | 
 76 | // Looks up the value of a global int slice flag, returns nil if no int slice flag exists
 77 | func (c *Context) GlobalIntSlice(name string) []int {
 78 | 	return lookupIntSlice(name, c.globalSet)
 79 | }
 80 | 
 81 | // Determines if the flag was actually set exists
 82 | func (c *Context) IsSet(name string) bool {
 83 | 	if c.setFlags == nil {
 84 | 		c.setFlags = make(map[string]bool)
 85 | 		c.flagSet.Visit(func(f *flag.Flag) {
 86 | 			c.setFlags[f.Name] = true
 87 | 		})
 88 | 	}
 89 | 	return c.setFlags[name] == true
 90 | }
 91 | 
 92 | type Args []string
 93 | 
 94 | // Returns the command line arguments associated with the context.
 95 | func (c *Context) Args() Args {
 96 | 	args := Args(c.flagSet.Args())
 97 | 	return args
 98 | }
 99 | 
100 | // Returns the nth argument, or else a blank string
101 | func (a Args) Get(n int) string {
102 | 	if len(a) > n {
103 | 		return a[n]
104 | 	}
105 | 	return ""
106 | }
107 | 
108 | // Returns the first argument, or else a blank string
109 | func (a Args) First() string {
110 | 	return a.Get(0)
111 | }
112 | 
113 | // Return the rest of the arguments (not the first one)
114 | // or else an empty string slice
115 | func (a Args) Tail() []string {
116 | 	if len(a) >= 2 {
117 | 		return []string(a)[1:]
118 | 	}
119 | 	return []string{}
120 | }
121 | 
122 | // Checks if there are any arguments present
123 | func (a Args) Present() bool {
124 | 	return len(a) != 0
125 | }
126 | 
127 | func lookupInt(name string, set *flag.FlagSet) int {
128 | 	f := set.Lookup(name)
129 | 	if f != nil {
130 | 		val, err := strconv.Atoi(f.Value.String())
131 | 		if err != nil {
132 | 			return 0
133 | 		}
134 | 		return val
135 | 	}
136 | 
137 | 	return 0
138 | }
139 | 
140 | func lookupFloat64(name string, set *flag.FlagSet) float64 {
141 | 	f := set.Lookup(name)
142 | 	if f != nil {
143 | 		val, err := strconv.ParseFloat(f.Value.String(), 64)
144 | 		if err != nil {
145 | 			return 0
146 | 		}
147 | 		return val
148 | 	}
149 | 
150 | 	return 0
151 | }
152 | 
153 | func lookupString(name string, set *flag.FlagSet) string {
154 | 	f := set.Lookup(name)
155 | 	if f != nil {
156 | 		return f.Value.String()
157 | 	}
158 | 
159 | 	return ""
160 | }
161 | 
162 | func lookupStringSlice(name string, set *flag.FlagSet) []string {
163 | 	f := set.Lookup(name)
164 | 	if f != nil {
165 | 		return (f.Value.(*StringSlice)).Value()
166 | 
167 | 	}
168 | 
169 | 	return nil
170 | }
171 | 
172 | func lookupIntSlice(name string, set *flag.FlagSet) []int {
173 | 	f := set.Lookup(name)
174 | 	if f != nil {
175 | 		return (f.Value.(*IntSlice)).Value()
176 | 
177 | 	}
178 | 
179 | 	return nil
180 | }
181 | 
182 | func lookupBool(name string, set *flag.FlagSet) bool {
183 | 	f := set.Lookup(name)
184 | 	if f != nil {
185 | 		val, err := strconv.ParseBool(f.Value.String())
186 | 		if err != nil {
187 | 			return false
188 | 		}
189 | 		return val
190 | 	}
191 | 
192 | 	return false
193 | }
194 | 
195 | func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
196 | 	visited := make(map[string]bool)
197 | 	set.Visit(func(f *flag.Flag) {
198 | 		visited[f.Name] = true
199 | 	})
200 | 	for _, f := range flags {
201 | 		parts := strings.Split(f.getName(), ",")
202 | 		if len(parts) == 1 {
203 | 			continue
204 | 		}
205 | 		var ff *flag.Flag
206 | 		for _, name := range parts {
207 | 			name = strings.Trim(name, " ")
208 | 			if visited[name] {
209 | 				if ff != nil {
210 | 					return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
211 | 				}
212 | 				ff = set.Lookup(name)
213 | 			}
214 | 		}
215 | 		if ff == nil {
216 | 			continue
217 | 		}
218 | 		for _, name := range parts {
219 | 			name = strings.Trim(name, " ")
220 | 			set.Set(name, ff.Value.String())
221 | 		}
222 | 	}
223 | 	return nil
224 | }
225 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/context_test.go:
--------------------------------------------------------------------------------
 1 | package cli_test
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"github.com/codegangsta/cli"
 6 | 	"testing"
 7 | )
 8 | 
 9 | func TestNewContext(t *testing.T) {
10 | 	set := flag.NewFlagSet("test", 0)
11 | 	set.Int("myflag", 12, "doc")
12 | 	globalSet := flag.NewFlagSet("test", 0)
13 | 	globalSet.Int("myflag", 42, "doc")
14 | 	c := cli.NewContext(nil, set, globalSet)
15 | 	expect(t, c.Int("myflag"), 12)
16 | 	expect(t, c.GlobalInt("myflag"), 42)
17 | }
18 | 
19 | func TestContext_Int(t *testing.T) {
20 | 	set := flag.NewFlagSet("test", 0)
21 | 	set.Int("myflag", 12, "doc")
22 | 	c := cli.NewContext(nil, set, set)
23 | 	expect(t, c.Int("myflag"), 12)
24 | }
25 | 
26 | func TestContext_String(t *testing.T) {
27 | 	set := flag.NewFlagSet("test", 0)
28 | 	set.String("myflag", "hello world", "doc")
29 | 	c := cli.NewContext(nil, set, set)
30 | 	expect(t, c.String("myflag"), "hello world")
31 | }
32 | 
33 | func TestContext_Bool(t *testing.T) {
34 | 	set := flag.NewFlagSet("test", 0)
35 | 	set.Bool("myflag", false, "doc")
36 | 	c := cli.NewContext(nil, set, set)
37 | 	expect(t, c.Bool("myflag"), false)
38 | }
39 | 
40 | func TestContext_Args(t *testing.T) {
41 | 	set := flag.NewFlagSet("test", 0)
42 | 	set.Bool("myflag", false, "doc")
43 | 	c := cli.NewContext(nil, set, set)
44 | 	set.Parse([]string{"--myflag", "bat", "baz"})
45 | 	expect(t, len(c.Args()), 2)
46 | 	expect(t, c.Bool("myflag"), true)
47 | }
48 | 
49 | func TestContext_IsSet(t *testing.T) {
50 | 	set := flag.NewFlagSet("test", 0)
51 | 	set.Bool("myflag", false, "doc")
52 | 	set.String("otherflag", "hello world", "doc")
53 | 	c := cli.NewContext(nil, set, set)
54 | 	set.Parse([]string{"--myflag", "bat", "baz"})
55 | 	expect(t, c.IsSet("myflag"), true)
56 | 	expect(t, c.IsSet("otherflag"), false)
57 | 	expect(t, c.IsSet("bogusflag"), false)
58 | }
59 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/flag.go:
--------------------------------------------------------------------------------
  1 | package cli
  2 | 
  3 | import (
  4 | 	"flag"
  5 | 	"fmt"
  6 | 	"strconv"
  7 | 	"strings"
  8 | )
  9 | 
 10 | // Flag is a common interface related to parsing flags in cli.
 11 | // For more advanced flag parsing techniques, it is recomended that
 12 | // this interface be implemented.
 13 | type Flag interface {
 14 | 	fmt.Stringer
 15 | 	// Apply Flag settings to the given flag set
 16 | 	Apply(*flag.FlagSet)
 17 | 	getName() string
 18 | }
 19 | 
 20 | func flagSet(name string, flags []Flag) *flag.FlagSet {
 21 | 	set := flag.NewFlagSet(name, flag.ContinueOnError)
 22 | 
 23 | 	for _, f := range flags {
 24 | 		f.Apply(set)
 25 | 	}
 26 | 	return set
 27 | }
 28 | 
 29 | func eachName(longName string, fn func(string)) {
 30 | 	parts := strings.Split(longName, ",")
 31 | 	for _, name := range parts {
 32 | 		name = strings.Trim(name, " ")
 33 | 		fn(name)
 34 | 	}
 35 | }
 36 | 
 37 | type StringSlice []string
 38 | 
 39 | func (f *StringSlice) Set(value string) error {
 40 | 	*f = append(*f, value)
 41 | 	return nil
 42 | }
 43 | 
 44 | func (f *StringSlice) String() string {
 45 | 	return fmt.Sprintf("%s", *f)
 46 | }
 47 | 
 48 | func (f *StringSlice) Value() []string {
 49 | 	return *f
 50 | }
 51 | 
 52 | type StringSliceFlag struct {
 53 | 	Name  string
 54 | 	Value *StringSlice
 55 | 	Usage string
 56 | }
 57 | 
 58 | func (f StringSliceFlag) String() string {
 59 | 	return fmt.Sprintf("%s%s %v\t`%v` %s", prefixFor(f.Name), f.Name, f.Value, "-"+f.Name+" option -"+f.Name+" option", f.Usage)
 60 | }
 61 | 
 62 | func (f StringSliceFlag) Apply(set *flag.FlagSet) {
 63 | 	eachName(f.Name, func(name string) {
 64 | 		set.Var(f.Value, name, f.Usage)
 65 | 	})
 66 | }
 67 | 
 68 | func (f StringSliceFlag) getName() string {
 69 | 	return f.Name
 70 | }
 71 | 
 72 | type IntSlice []int
 73 | 
 74 | func (f *IntSlice) Set(value string) error {
 75 | 
 76 | 	tmp, err := strconv.Atoi(value)
 77 | 	if err != nil {
 78 | 		return err
 79 | 	} else {
 80 | 		*f = append(*f, tmp)
 81 | 	}
 82 | 	return nil
 83 | }
 84 | 
 85 | func (f *IntSlice) String() string {
 86 | 	return fmt.Sprintf("%d", *f)
 87 | }
 88 | 
 89 | func (f *IntSlice) Value() []int {
 90 | 	return *f
 91 | }
 92 | 
 93 | type IntSliceFlag struct {
 94 | 	Name  string
 95 | 	Value *IntSlice
 96 | 	Usage string
 97 | }
 98 | 
 99 | func (f IntSliceFlag) String() string {
100 | 	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
101 | 	pref := prefixFor(firstName)
102 | 	return fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage)
103 | }
104 | 
105 | func (f IntSliceFlag) Apply(set *flag.FlagSet) {
106 | 	eachName(f.Name, func(name string) {
107 | 		set.Var(f.Value, name, f.Usage)
108 | 	})
109 | }
110 | 
111 | func (f IntSliceFlag) getName() string {
112 | 	return f.Name
113 | }
114 | 
115 | type BoolFlag struct {
116 | 	Name  string
117 | 	Usage string
118 | }
119 | 
120 | func (f BoolFlag) String() string {
121 | 	return fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage)
122 | }
123 | 
124 | func (f BoolFlag) Apply(set *flag.FlagSet) {
125 | 	eachName(f.Name, func(name string) {
126 | 		set.Bool(name, false, f.Usage)
127 | 	})
128 | }
129 | 
130 | func (f BoolFlag) getName() string {
131 | 	return f.Name
132 | }
133 | 
134 | type StringFlag struct {
135 | 	Name  string
136 | 	Value string
137 | 	Usage string
138 | 	OmitDefaultValue bool
139 | }
140 | 
141 | func (f StringFlag) String() string {
142 | 	if f.OmitDefaultValue {
143 | 		return fmt.Sprintf("%s \t%v", prefixedNames(f.Name), f.Usage)
144 | 	} else {
145 | 		return fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), f.Value, f.Usage)
146 | 	}
147 | }
148 | 
149 | func (f StringFlag) Apply(set *flag.FlagSet) {
150 | 	eachName(f.Name, func(name string) {
151 | 		set.String(name, f.Value, f.Usage)
152 | 	})
153 | }
154 | 
155 | func (f StringFlag) getName() string {
156 | 	return f.Name
157 | }
158 | 
159 | type IntFlag struct {
160 | 	Name  string
161 | 	Value int
162 | 	Usage string
163 | 	OmitDefaultValue bool
164 | }
165 | 
166 | func (f IntFlag) String() string {
167 | 	if f.OmitDefaultValue {
168 | 		return fmt.Sprintf("%s \t%v", prefixedNames(f.Name), f.Usage)
169 | 	} else {
170 | 		return fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), f.Value, f.Usage)
171 | 	}
172 | }
173 | 
174 | func (f IntFlag) Apply(set *flag.FlagSet) {
175 | 	eachName(f.Name, func(name string) {
176 | 		set.Int(name, f.Value, f.Usage)
177 | 	})
178 | }
179 | 
180 | func (f IntFlag) getName() string {
181 | 	return f.Name
182 | }
183 | 
184 | type Float64Flag struct {
185 | 	Name  string
186 | 	Value float64
187 | 	Usage string
188 | 	OmitDefaultValue bool
189 | }
190 | 
191 | func (f Float64Flag) String() string {
192 | 	if f.OmitDefaultValue {
193 | 		return fmt.Sprintf("%s \t%v", prefixedNames(f.Name), f.Usage)
194 | 	} else {
195 | 		return fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), f.Value, f.Usage)
196 | 	}
197 | }
198 | 
199 | func (f Float64Flag) Apply(set *flag.FlagSet) {
200 | 	eachName(f.Name, func(name string) {
201 | 		set.Float64(name, f.Value, f.Usage)
202 | 	})
203 | }
204 | 
205 | func (f Float64Flag) getName() string {
206 | 	return f.Name
207 | }
208 | 
209 | func prefixFor(name string) (prefix string) {
210 | 	if len(name) == 1 {
211 | 		prefix = "-"
212 | 	} else {
213 | 		prefix = "--"
214 | 	}
215 | 
216 | 	return
217 | }
218 | 
219 | func prefixedNames(fullName string) (prefixed string) {
220 | 	parts := strings.Split(fullName, ",")
221 | 	for i, name := range parts {
222 | 		name = strings.Trim(name, " ")
223 | 		prefixed += prefixFor(name) + name
224 | 		if i < len(parts)-1 {
225 | 			prefixed += ", "
226 | 		}
227 | 	}
228 | 	return
229 | }
230 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/flag_test.go:
--------------------------------------------------------------------------------
  1 | package cli_test
  2 | 
  3 | import (
  4 | 	"github.com/codegangsta/cli"
  5 | 	"testing"
  6 | )
  7 | 
  8 | var boolFlagTests = []struct {
  9 | 	name     string
 10 | 	expected string
 11 | }{
 12 | 	{"help", "--help\t"},
 13 | 	{"h", "-h\t"},
 14 | }
 15 | 
 16 | func TestBoolFlagHelpOutput(t *testing.T) {
 17 | 
 18 | 	for _, test := range boolFlagTests {
 19 | 		flag := cli.BoolFlag{Name: test.name}
 20 | 		output := flag.String()
 21 | 
 22 | 		if output != test.expected {
 23 | 			t.Errorf("%s does not match %s", output, test.expected)
 24 | 		}
 25 | 	}
 26 | }
 27 | 
 28 | var stringFlagTests = []struct {
 29 | 	name     string
 30 | 	expected string
 31 | }{
 32 | 	{"help", "--help ''\t"},
 33 | 	{"h", "-h ''\t"},
 34 | }
 35 | 
 36 | func TestStringFlagHelpOutput(t *testing.T) {
 37 | 
 38 | 	for _, test := range stringFlagTests {
 39 | 		flag := cli.StringFlag{Name: test.name}
 40 | 		output := flag.String()
 41 | 
 42 | 		if output != test.expected {
 43 | 			t.Errorf("%s does not match %s", output, test.expected)
 44 | 		}
 45 | 	}
 46 | }
 47 | 
 48 | var intFlagTests = []struct {
 49 | 	name     string
 50 | 	expected string
 51 | }{
 52 | 	{"help", "--help '0'\t"},
 53 | 	{"h", "-h '0'\t"},
 54 | }
 55 | 
 56 | func TestIntFlagHelpOutput(t *testing.T) {
 57 | 
 58 | 	for _, test := range intFlagTests {
 59 | 		flag := cli.IntFlag{Name: test.name}
 60 | 		output := flag.String()
 61 | 
 62 | 		if output != test.expected {
 63 | 			t.Errorf("%s does not match %s", output, test.expected)
 64 | 		}
 65 | 	}
 66 | }
 67 | 
 68 | var float64FlagTests = []struct {
 69 | 	name     string
 70 | 	expected string
 71 | }{
 72 | 	{"help", "--help '0'\t"},
 73 | 	{"h", "-h '0'\t"},
 74 | }
 75 | 
 76 | func TestFloat64FlagHelpOutput(t *testing.T) {
 77 | 
 78 | 	for _, test := range float64FlagTests {
 79 | 		flag := cli.Float64Flag{Name: test.name}
 80 | 		output := flag.String()
 81 | 
 82 | 		if output != test.expected {
 83 | 			t.Errorf("%s does not match %s", output, test.expected)
 84 | 		}
 85 | 	}
 86 | }
 87 | 
 88 | func TestParseMultiString(t *testing.T) {
 89 | 	(&cli.App{
 90 | 		Flags: []cli.Flag{
 91 | 			cli.StringFlag{Name: "serve, s"},
 92 | 		},
 93 | 		Action: func(ctx *cli.Context) {
 94 | 			if ctx.String("serve") != "10" {
 95 | 				t.Errorf("main name not set")
 96 | 			}
 97 | 			if ctx.String("s") != "10" {
 98 | 				t.Errorf("short name not set")
 99 | 			}
100 | 		},
101 | 	}).Run([]string{"run", "-s", "10"})
102 | }
103 | 
104 | func TestParseMultiInt(t *testing.T) {
105 | 	a := cli.App{
106 | 		Flags: []cli.Flag{
107 | 			cli.IntFlag{Name: "serve, s"},
108 | 		},
109 | 		Action: func(ctx *cli.Context) {
110 | 			if ctx.Int("serve") != 10 {
111 | 				t.Errorf("main name not set")
112 | 			}
113 | 			if ctx.Int("s") != 10 {
114 | 				t.Errorf("short name not set")
115 | 			}
116 | 		},
117 | 	}
118 | 	a.Run([]string{"run", "-s", "10"})
119 | }
120 | 
121 | func TestParseMultiBool(t *testing.T) {
122 | 	a := cli.App{
123 | 		Flags: []cli.Flag{
124 | 			cli.BoolFlag{Name: "serve, s"},
125 | 		},
126 | 		Action: func(ctx *cli.Context) {
127 | 			if ctx.Bool("serve") != true {
128 | 				t.Errorf("main name not set")
129 | 			}
130 | 			if ctx.Bool("s") != true {
131 | 				t.Errorf("short name not set")
132 | 			}
133 | 		},
134 | 	}
135 | 	a.Run([]string{"run", "--serve"})
136 | }
137 | 
138 | func TestStringFlagWithoutDefaultValue(t *testing.T) {
139 | 	flag := cli.StringFlag{Name: "help", Usage: "Show help", OmitDefaultValue: true}
140 | 	output := flag.String()
141 | 
142 | 	if output != "--help \tShow help" {
143 | 		t.Errorf("string without default value should omit default value")
144 | 	}
145 | }
146 | 
147 | func TestIntFlagWithoutDefaultValue(t *testing.T) {
148 | 	flag := cli.IntFlag{Name: "help", Usage: "Prints number of help topics", OmitDefaultValue: true}
149 | 	output := flag.String()
150 | 	expected:= "--help \tPrints number of help topics"
151 | 
152 | 	if output != expected {
153 | 		t.Errorf("expected '%s' to equal '%s", output, expected)
154 | 	}
155 | }
156 | 
157 | func TestFloatFlagWithoutDefaultValue(t *testing.T) {
158 | 	flag := cli.Float64Flag{Name: "help", Usage: "Prints floating help topics", OmitDefaultValue: true}
159 | 	output := flag.String()
160 | 	expected:= "--help \tPrints floating help topics"
161 | 
162 | 	if output != expected {
163 | 		t.Errorf("expected '%s' to equal '%s", output, expected)
164 | 	}
165 | }
166 | 
167 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/help.go:
--------------------------------------------------------------------------------
  1 | package cli
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"os"
  6 | 	"text/tabwriter"
  7 | 	"text/template"
  8 | )
  9 | 
 10 | // The text template for the Default help topic.
 11 | // cli.go uses text/template to render templates. You can
 12 | // render custom help text by setting this variable.
 13 | var AppHelpTemplate = `NAME:
 14 |    {{.Name}} - {{.Usage}}
 15 | 
 16 | USAGE:
 17 |    {{.Name}} [global options] command [command options] [arguments...]
 18 | 
 19 | VERSION:
 20 |    {{.Version}}
 21 | 
 22 | COMMANDS:
 23 |    {{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
 24 |    {{end}}
 25 | GLOBAL OPTIONS:
 26 |    {{range .Flags}}{{.}}
 27 |    {{end}}
 28 | `
 29 | 
 30 | // The text template for the command help topic.
 31 | // cli.go uses text/template to render templates. You can
 32 | // render custom help text by setting this variable.
 33 | var CommandHelpTemplate = `NAME:
 34 |    {{.Name}} - {{.Usage}}
 35 | 
 36 | USAGE:
 37 |    command {{.Name}} [command options] [arguments...]
 38 | 
 39 | DESCRIPTION:
 40 |    {{.Description}}
 41 | 
 42 | OPTIONS:
 43 |    {{range .Flags}}{{.}}
 44 |    {{end}}
 45 | `
 46 | 
 47 | var helpCommand = Command{
 48 | 	Name:      "help",
 49 | 	ShortName: "h",
 50 | 	Usage:     "Shows a list of commands or help for one command",
 51 | 	Action: func(c *Context) {
 52 | 		args := c.Args()
 53 | 		if args.Present() {
 54 | 			ShowCommandHelp(c, args.First())
 55 | 		} else {
 56 | 			ShowAppHelp(c)
 57 | 		}
 58 | 	},
 59 | }
 60 | 
 61 | // Prints help for the App
 62 | func ShowAppHelp(c *Context) {
 63 | 	printHelp(AppHelpTemplate, c.App)
 64 | }
 65 | 
 66 | // Prints help for the given command
 67 | func ShowCommandHelp(c *Context, command string) {
 68 | 	for _, c := range c.App.Commands {
 69 | 		if c.HasName(command) {
 70 | 			printHelp(CommandHelpTemplate, c)
 71 | 			return
 72 | 		}
 73 | 	}
 74 | 
 75 | 	fmt.Printf("No help topic for '%v'\n", command)
 76 | }
 77 | 
 78 | // Prints the version number of the App
 79 | func ShowVersion(c *Context) {
 80 | 	fmt.Printf("%v version %v\n", c.App.Name, c.App.Version)
 81 | }
 82 | 
 83 | func printHelp(templ string, data interface{}) {
 84 | 	w := tabwriter.NewWriter(os.Stdout, 0, 8, 1, '\t', 0)
 85 | 	t := template.Must(template.New("help").Parse(templ))
 86 | 	err := t.Execute(w, data)
 87 | 	if err != nil {
 88 | 		panic(err)
 89 | 	}
 90 | 	w.Flush()
 91 | }
 92 | 
 93 | func checkVersion(c *Context) bool {
 94 | 	if c.GlobalBool("version") {
 95 | 		ShowVersion(c)
 96 | 		return true
 97 | 	}
 98 | 
 99 | 	return false
100 | }
101 | 
102 | func checkHelp(c *Context) bool {
103 | 	if c.GlobalBool("h") || c.GlobalBool("help") {
104 | 		ShowAppHelp(c)
105 | 		return true
106 | 	}
107 | 
108 | 	return false
109 | }
110 | 
111 | func checkCommandHelp(c *Context, name string) bool {
112 | 	if c.Bool("h") || c.Bool("help") {
113 | 		ShowCommandHelp(c, name)
114 | 		return true
115 | 	}
116 | 
117 | 	return false
118 | }
119 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/codegangsta/cli/helpers_test.go:
--------------------------------------------------------------------------------
 1 | package cli_test
 2 | 
 3 | import (
 4 | 	"reflect"
 5 | 	"testing"
 6 | )
 7 | 
 8 | /* Test Helpers */
 9 | func expect(t *testing.T, a interface{}, b interface{}) {
10 | 	if a != b {
11 | 		t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
12 | 	}
13 | }
14 | 
15 | func refute(t *testing.T, a interface{}, b interface{}) {
16 | 	if a == b {
17 | 		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/.gitignore:
--------------------------------------------------------------------------------
1 | config.json
2 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/README.md:
--------------------------------------------------------------------------------
 1 | # go-etcd
 2 | 
 3 | The official etcd v0.2 client library for Go.
 4 | 
 5 | For usage, please refer to: [go-etcd/etcd](http://godoc.org/github.com/coreos/go-etcd/etcd).
 6 | 
 7 | ## Install
 8 | 
 9 | ```bash
10 | go get github.com/coreos/go-etcd/etcd
11 | ```
12 | 
13 | ## License
14 | 
15 | See LICENSE file.
16 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/add_child.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | // Add a new directory with a random etcd-generated key under the given path.
 4 | func (c *Client) AddChildDir(key string, ttl uint64) (*Response, error) {
 5 | 	raw, err := c.post(key, "", ttl)
 6 | 
 7 | 	if err != nil {
 8 | 		return nil, err
 9 | 	}
10 | 
11 | 	return raw.toResponse()
12 | }
13 | 
14 | // Add a new file with a random etcd-generated key under the given path.
15 | func (c *Client) AddChild(key string, value string, ttl uint64) (*Response, error) {
16 | 	raw, err := c.post(key, value, ttl)
17 | 
18 | 	if err != nil {
19 | 		return nil, err
20 | 	}
21 | 
22 | 	return raw.toResponse()
23 | }
24 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/add_child_test.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import "testing"
 4 | 
 5 | func TestAddChild(t *testing.T) {
 6 | 	c := NewClient(nil)
 7 | 	defer func() {
 8 | 		c.Delete("fooDir", true)
 9 | 		c.Delete("nonexistentDir", true)
10 | 	}()
11 | 
12 | 	c.CreateDir("fooDir", 5)
13 | 
14 | 	_, err := c.AddChild("fooDir", "v0", 5)
15 | 	if err != nil {
16 | 		t.Fatal(err)
17 | 	}
18 | 
19 | 	_, err = c.AddChild("fooDir", "v1", 5)
20 | 	if err != nil {
21 | 		t.Fatal(err)
22 | 	}
23 | 
24 | 	resp, err := c.Get("fooDir", true, false)
25 | 	// The child with v0 should proceed the child with v1 because it's added
26 | 	// earlier, so it should have a lower key.
27 | 	if !(len(resp.Node.Nodes) == 2 && (resp.Node.Nodes[0].Value == "v0" && resp.Node.Nodes[1].Value == "v1")) {
28 | 		t.Fatalf("AddChild 1 failed.  There should be two chlidren whose values are v0 and v1, respectively."+
29 | 			"  The response was: %#v", resp)
30 | 	}
31 | 
32 | 	// Creating a child under a nonexistent directory should succeed.
33 | 	// The directory should be created.
34 | 	resp, err = c.AddChild("nonexistentDir", "foo", 5)
35 | 	if err != nil {
36 | 		t.Fatal(err)
37 | 	}
38 | }
39 | 
40 | func TestAddChildDir(t *testing.T) {
41 | 	c := NewClient(nil)
42 | 	defer func() {
43 | 		c.Delete("fooDir", true)
44 | 		c.Delete("nonexistentDir", true)
45 | 	}()
46 | 
47 | 	c.CreateDir("fooDir", 5)
48 | 
49 | 	_, err := c.AddChildDir("fooDir", 5)
50 | 	if err != nil {
51 | 		t.Fatal(err)
52 | 	}
53 | 
54 | 	_, err = c.AddChildDir("fooDir", 5)
55 | 	if err != nil {
56 | 		t.Fatal(err)
57 | 	}
58 | 
59 | 	resp, err := c.Get("fooDir", true, false)
60 | 	// The child with v0 should proceed the child with v1 because it's added
61 | 	// earlier, so it should have a lower key.
62 | 	if !(len(resp.Node.Nodes) == 2 && (len(resp.Node.Nodes[0].Nodes) == 0 && len(resp.Node.Nodes[1].Nodes) == 0)) {
63 | 		t.Fatalf("AddChildDir 1 failed.  There should be two chlidren whose values are v0 and v1, respectively."+
64 | 			"  The response was: %#v", resp)
65 | 	}
66 | 
67 | 	// Creating a child under a nonexistent directory should succeed.
68 | 	// The directory should be created.
69 | 	resp, err = c.AddChildDir("nonexistentDir", 5)
70 | 	if err != nil {
71 | 		t.Fatal(err)
72 | 	}
73 | }
74 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/client.go:
--------------------------------------------------------------------------------
  1 | package etcd
  2 | 
  3 | import (
  4 | 	"crypto/tls"
  5 | 	"crypto/x509"
  6 | 	"encoding/json"
  7 | 	"errors"
  8 | 	"io"
  9 | 	"io/ioutil"
 10 | 	"net"
 11 | 	"net/http"
 12 | 	"net/url"
 13 | 	"os"
 14 | 	"path"
 15 | 	"strings"
 16 | 	"time"
 17 | )
 18 | 
 19 | const (
 20 | 	HTTP = iota
 21 | 	HTTPS
 22 | )
 23 | 
 24 | // See SetConsistency for how to use these constants.
 25 | const (
 26 | 	// Using strings rather than iota because the consistency level
 27 | 	// could be persisted to disk, so it'd be better to use
 28 | 	// human-readable values.
 29 | 	STRONG_CONSISTENCY = "STRONG"
 30 | 	WEAK_CONSISTENCY   = "WEAK"
 31 | )
 32 | 
 33 | const (
 34 | 	defaultBufferSize = 10
 35 | )
 36 | 
 37 | type Cluster struct {
 38 | 	Leader   string   `json:"leader"`
 39 | 	Machines []string `json:"machines"`
 40 | }
 41 | 
 42 | type Config struct {
 43 | 	CertFile    string        `json:"certFile"`
 44 | 	KeyFile     string        `json:"keyFile"`
 45 | 	CaCertFile  string        `json:"caCertFile"`
 46 | 	Scheme      string        `json:"scheme"`
 47 | 	Timeout     time.Duration `json:"timeout"`
 48 | 	Consistency string        `json: "consistency"`
 49 | }
 50 | 
 51 | type Client struct {
 52 | 	cluster     Cluster `json:"cluster"`
 53 | 	config      Config  `json:"config"`
 54 | 	httpClient  *http.Client
 55 | 	persistence io.Writer
 56 | 	cURLch      chan string
 57 | }
 58 | 
 59 | // NewClient create a basic client that is configured to be used
 60 | // with the given machine list.
 61 | func NewClient(machines []string) *Client {
 62 | 	// if an empty slice was sent in then just assume localhost
 63 | 	if len(machines) == 0 {
 64 | 		machines = []string{"http://127.0.0.1:4001"}
 65 | 	}
 66 | 
 67 | 	// default leader and machines
 68 | 	cluster := Cluster{
 69 | 		Leader:   machines[0],
 70 | 		Machines: machines,
 71 | 	}
 72 | 
 73 | 	config := Config{
 74 | 		// default use http
 75 | 		Scheme: "http",
 76 | 		// default timeout is one second
 77 | 		Timeout: time.Second,
 78 | 		// default consistency level is STRONG
 79 | 		Consistency: STRONG_CONSISTENCY,
 80 | 	}
 81 | 
 82 | 	client := &Client{
 83 | 		cluster: cluster,
 84 | 		config:  config,
 85 | 	}
 86 | 
 87 | 	err := setupHttpClient(client)
 88 | 	if err != nil {
 89 | 		panic(err)
 90 | 	}
 91 | 
 92 | 	return client
 93 | }
 94 | 
 95 | // NewClientFile creates a client from a given file path.
 96 | // The given file is expected to use the JSON format.
 97 | func NewClientFile(fpath string) (*Client, error) {
 98 | 	fi, err := os.Open(fpath)
 99 | 	if err != nil {
100 | 		return nil, err
101 | 	}
102 | 	defer func() {
103 | 		if err := fi.Close(); err != nil {
104 | 			panic(err)
105 | 		}
106 | 	}()
107 | 
108 | 	return NewClientReader(fi)
109 | }
110 | 
111 | // NewClientReader creates a Client configured from a given reader.
112 | // The config is expected to use the JSON format.
113 | func NewClientReader(reader io.Reader) (*Client, error) {
114 | 	var client Client
115 | 
116 | 	b, err := ioutil.ReadAll(reader)
117 | 	if err != nil {
118 | 		return nil, err
119 | 	}
120 | 
121 | 	err = json.Unmarshal(b, &client)
122 | 	if err != nil {
123 | 		return nil, err
124 | 	}
125 | 
126 | 	err = setupHttpClient(&client)
127 | 	if err != nil {
128 | 		return nil, err
129 | 	}
130 | 
131 | 	return &client, nil
132 | }
133 | 
134 | func setupHttpClient(client *Client) error {
135 | 	if client.config.CertFile != "" && client.config.KeyFile != "" {
136 | 		err := client.SetCertAndKey(client.config.CertFile, client.config.KeyFile, client.config.CaCertFile)
137 | 		if err != nil {
138 | 			return err
139 | 		}
140 | 	} else {
141 | 		client.config.CertFile = ""
142 | 		client.config.KeyFile = ""
143 | 		tr := &http.Transport{
144 | 			Dial: dialTimeout,
145 | 			TLSClientConfig: &tls.Config{
146 | 				InsecureSkipVerify: true,
147 | 			},
148 | 		}
149 | 		client.httpClient = &http.Client{Transport: tr}
150 | 	}
151 | 
152 | 	return nil
153 | }
154 | 
155 | // SetPersistence sets a writer to which the config will be
156 | // written every time it's changed.
157 | func (c *Client) SetPersistence(writer io.Writer) {
158 | 	c.persistence = writer
159 | }
160 | 
161 | // SetConsistency changes the consistency level of the client.
162 | //
163 | // When consistency is set to STRONG_CONSISTENCY, all requests,
164 | // including GET, are sent to the leader.  This means that, assuming
165 | // the absence of leader failures, GET requests are guaranteed to see
166 | // the changes made by previous requests.
167 | //
168 | // When consistency is set to WEAK_CONSISTENCY, other requests
169 | // are still sent to the leader, but GET requests are sent to a
170 | // random server from the server pool.  This reduces the read
171 | // load on the leader, but it's not guaranteed that the GET requests
172 | // will see changes made by previous requests (they might have not
173 | // yet been committed on non-leader servers).
174 | func (c *Client) SetConsistency(consistency string) error {
175 | 	if !(consistency == STRONG_CONSISTENCY || consistency == WEAK_CONSISTENCY) {
176 | 		return errors.New("The argument must be either STRONG_CONSISTENCY or WEAK_CONSISTENCY.")
177 | 	}
178 | 	c.config.Consistency = consistency
179 | 	return nil
180 | }
181 | 
182 | // MarshalJSON implements the Marshaller interface
183 | // as defined by the standard JSON package.
184 | func (c *Client) MarshalJSON() ([]byte, error) {
185 | 	b, err := json.Marshal(struct {
186 | 		Config  Config  `json:"config"`
187 | 		Cluster Cluster `json:"cluster"`
188 | 	}{
189 | 		Config:  c.config,
190 | 		Cluster: c.cluster,
191 | 	})
192 | 
193 | 	if err != nil {
194 | 		return nil, err
195 | 	}
196 | 
197 | 	return b, nil
198 | }
199 | 
200 | // UnmarshalJSON implements the Unmarshaller interface
201 | // as defined by the standard JSON package.
202 | func (c *Client) UnmarshalJSON(b []byte) error {
203 | 	temp := struct {
204 | 		Config  Config  `json: "config"`
205 | 		Cluster Cluster `json: "cluster"`
206 | 	}{}
207 | 	err := json.Unmarshal(b, &temp)
208 | 	if err != nil {
209 | 		return err
210 | 	}
211 | 
212 | 	c.cluster = temp.Cluster
213 | 	c.config = temp.Config
214 | 	return nil
215 | }
216 | 
217 | // saveConfig saves the current config using c.persistence.
218 | func (c *Client) saveConfig() error {
219 | 	if c.persistence != nil {
220 | 		b, err := json.Marshal(c)
221 | 		if err != nil {
222 | 			return err
223 | 		}
224 | 
225 | 		_, err = c.persistence.Write(b)
226 | 		if err != nil {
227 | 			return err
228 | 		}
229 | 	}
230 | 
231 | 	return nil
232 | }
233 | 
234 | func (c *Client) SetCertAndKey(cert string, key string, caCert string) error {
235 | 	if cert != "" && key != "" {
236 | 		tlsCert, err := tls.LoadX509KeyPair(cert, key)
237 | 
238 | 		if err != nil {
239 | 			return err
240 | 		}
241 | 
242 | 		tlsConfig := &tls.Config{
243 | 			Certificates: []tls.Certificate{tlsCert},
244 | 		}
245 | 
246 | 		if caCert != "" {
247 | 			caCertPool := x509.NewCertPool()
248 | 
249 | 			certBytes, err := ioutil.ReadFile(caCert)
250 | 			if err != nil {
251 | 				return err
252 | 			}
253 | 
254 | 			if !caCertPool.AppendCertsFromPEM(certBytes) {
255 | 				return errors.New("Unable to load caCert")
256 | 			}
257 | 
258 | 			tlsConfig.RootCAs = caCertPool
259 | 		} else {
260 | 			tlsConfig.InsecureSkipVerify = true
261 | 		}
262 | 
263 | 		tr := &http.Transport{
264 | 			TLSClientConfig: tlsConfig,
265 | 			Dial:            dialTimeout,
266 | 		}
267 | 
268 | 		c.httpClient = &http.Client{Transport: tr}
269 | 		c.saveConfig()
270 | 		return nil
271 | 	}
272 | 	return errors.New("Require both cert and key path")
273 | }
274 | 
275 | func (c *Client) SetScheme(scheme int) error {
276 | 	if scheme == HTTP {
277 | 		c.config.Scheme = "http"
278 | 		c.saveConfig()
279 | 		return nil
280 | 	}
281 | 	if scheme == HTTPS {
282 | 		c.config.Scheme = "https"
283 | 		c.saveConfig()
284 | 		return nil
285 | 	}
286 | 	return errors.New("Unknown Scheme")
287 | }
288 | 
289 | // SetCluster updates config using the given machine list.
290 | func (c *Client) SetCluster(machines []string) bool {
291 | 	success := c.internalSyncCluster(machines)
292 | 	return success
293 | }
294 | 
295 | func (c *Client) GetCluster() []string {
296 | 	return c.cluster.Machines
297 | }
298 | 
299 | // SyncCluster updates config using the internal machine list.
300 | func (c *Client) SyncCluster() bool {
301 | 	success := c.internalSyncCluster(c.cluster.Machines)
302 | 	return success
303 | }
304 | 
305 | // internalSyncCluster syncs cluster information using the given machine list.
306 | func (c *Client) internalSyncCluster(machines []string) bool {
307 | 	for _, machine := range machines {
308 | 		httpPath := c.createHttpPath(machine, version+"/machines")
309 | 		resp, err := c.httpClient.Get(httpPath)
310 | 		if err != nil {
311 | 			// try another machine in the cluster
312 | 			continue
313 | 		} else {
314 | 			b, err := ioutil.ReadAll(resp.Body)
315 | 			resp.Body.Close()
316 | 			if err != nil {
317 | 				// try another machine in the cluster
318 | 				continue
319 | 			}
320 | 
321 | 			// update Machines List
322 | 			c.cluster.Machines = strings.Split(string(b), ", ")
323 | 
324 | 			// update leader
325 | 			// the first one in the machine list is the leader
326 | 			logger.Debugf("update.leader[%s,%s]", c.cluster.Leader, c.cluster.Machines[0])
327 | 			c.cluster.Leader = c.cluster.Machines[0]
328 | 
329 | 			logger.Debug("sync.machines ", c.cluster.Machines)
330 | 			c.saveConfig()
331 | 			return true
332 | 		}
333 | 	}
334 | 	return false
335 | }
336 | 
337 | // createHttpPath creates a complete HTTP URL.
338 | // serverName should contain both the host name and a port number, if any.
339 | func (c *Client) createHttpPath(serverName string, _path string) string {
340 | 	u, _ := url.Parse(serverName)
341 | 	u.Path = path.Join(u.Path, "/", _path)
342 | 
343 | 	if u.Scheme == "" {
344 | 		u.Scheme = "http"
345 | 	}
346 | 	return u.String()
347 | }
348 | 
349 | // Dial with timeout.
350 | func dialTimeout(network, addr string) (net.Conn, error) {
351 | 	return net.DialTimeout(network, addr, time.Second)
352 | }
353 | 
354 | func (c *Client) updateLeader(u *url.URL) {
355 | 	var leader string
356 | 	if u.Scheme == "" {
357 | 		leader = "http://" + u.Host
358 | 	} else {
359 | 		leader = u.Scheme + "://" + u.Host
360 | 	}
361 | 
362 | 	logger.Debugf("update.leader[%s,%s]", c.cluster.Leader, leader)
363 | 	c.cluster.Leader = leader
364 | 	c.saveConfig()
365 | }
366 | 
367 | // switchLeader switch the current leader to machines[num]
368 | func (c *Client) switchLeader(num int) {
369 | 	logger.Debugf("switch.leader[from %v to %v]",
370 | 		c.cluster.Leader, c.cluster.Machines[num])
371 | 
372 | 	c.cluster.Leader = c.cluster.Machines[num]
373 | }
374 | 
375 | func (c *Client) OpenCURL() {
376 | 	c.cURLch = make(chan string, defaultBufferSize)
377 | }
378 | 
379 | func (c *Client) CloseCURL() {
380 | 	c.cURLch = nil
381 | }
382 | 
383 | func (c *Client) sendCURL(command string) {
384 | 	go func() {
385 | 		select {
386 | 		case c.cURLch <- command:
387 | 		default:
388 | 		}
389 | 	}()
390 | }
391 | 
392 | func (c *Client) RecvCURL() string {
393 | 	return <-c.cURLch
394 | }
395 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/client_test.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"fmt"
 6 | 	"net"
 7 | 	"net/url"
 8 | 	"os"
 9 | 	"testing"
10 | )
11 | 
12 | // To pass this test, we need to create a cluster of 3 machines
13 | // The server should be listening on 127.0.0.1:4001, 4002, 4003
14 | func TestSync(t *testing.T) {
15 | 	fmt.Println("Make sure there are three nodes at 0.0.0.0:4001-4003")
16 | 
17 | 	c := NewClient(nil)
18 | 
19 | 	success := c.SyncCluster()
20 | 	if !success {
21 | 		t.Fatal("cannot sync machines")
22 | 	}
23 | 
24 | 	for _, m := range c.GetCluster() {
25 | 		u, err := url.Parse(m)
26 | 		if err != nil {
27 | 			t.Fatal(err)
28 | 		}
29 | 		if u.Scheme != "http" {
30 | 			t.Fatal("scheme must be http")
31 | 		}
32 | 
33 | 		host, _, err := net.SplitHostPort(u.Host)
34 | 		if err != nil {
35 | 			t.Fatal(err)
36 | 		}
37 | 		if host != "127.0.0.1" {
38 | 			t.Fatal("Host must be 127.0.0.1")
39 | 		}
40 | 	}
41 | 
42 | 	badMachines := []string{"abc", "edef"}
43 | 
44 | 	success = c.SetCluster(badMachines)
45 | 
46 | 	if success {
47 | 		t.Fatal("should not sync on bad machines")
48 | 	}
49 | 
50 | 	goodMachines := []string{"127.0.0.1:4002"}
51 | 
52 | 	success = c.SetCluster(goodMachines)
53 | 
54 | 	if !success {
55 | 		t.Fatal("cannot sync machines")
56 | 	} else {
57 | 		fmt.Println(c.cluster.Machines)
58 | 	}
59 | 
60 | }
61 | 
62 | func TestPersistence(t *testing.T) {
63 | 	c := NewClient(nil)
64 | 	c.SyncCluster()
65 | 
66 | 	fo, err := os.Create("config.json")
67 | 	if err != nil {
68 | 		t.Fatal(err)
69 | 	}
70 | 	defer func() {
71 | 		if err := fo.Close(); err != nil {
72 | 			panic(err)
73 | 		}
74 | 	}()
75 | 
76 | 	c.SetPersistence(fo)
77 | 	err = c.saveConfig()
78 | 	if err != nil {
79 | 		t.Fatal(err)
80 | 	}
81 | 
82 | 	c2, err := NewClientFile("config.json")
83 | 	if err != nil {
84 | 		t.Fatal(err)
85 | 	}
86 | 
87 | 	// Verify that the two clients have the same config
88 | 	b1, _ := json.Marshal(c)
89 | 	b2, _ := json.Marshal(c2)
90 | 
91 | 	if string(b1) != string(b2) {
92 | 		t.Fatalf("The two configs should be equal!")
93 | 	}
94 | }
95 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/compare_and_swap.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import "fmt"
 4 | 
 5 | func (c *Client) CompareAndSwap(key string, value string, ttl uint64, prevValue string, prevIndex uint64) (*Response, error) {
 6 | 	if prevValue == "" && prevIndex == 0 {
 7 | 		return nil, fmt.Errorf("You must give either prevValue or prevIndex.")
 8 | 	}
 9 | 
10 | 	options := options{}
11 | 	if prevValue != "" {
12 | 		options["prevValue"] = prevValue
13 | 	}
14 | 	if prevIndex != 0 {
15 | 		options["prevIndex"] = prevIndex
16 | 	}
17 | 
18 | 	raw, err := c.put(key, value, ttl, options)
19 | 
20 | 	if err != nil {
21 | 		return nil, err
22 | 	}
23 | 
24 | 	return raw.toResponse()
25 | }
26 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/compare_and_swap_test.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import (
 4 | 	"testing"
 5 | )
 6 | 
 7 | func TestCompareAndSwap(t *testing.T) {
 8 | 	c := NewClient(nil)
 9 | 	defer func() {
10 | 		c.Delete("foo", true)
11 | 	}()
12 | 
13 | 	c.Set("foo", "bar", 5)
14 | 
15 | 	// This should succeed
16 | 	resp, err := c.CompareAndSwap("foo", "bar2", 5, "bar", 0)
17 | 	if err != nil {
18 | 		t.Fatal(err)
19 | 	}
20 | 	if !(resp.Node.Value == "bar2" && resp.Node.Key == "/foo" && resp.Node.TTL == 5) {
21 | 		t.Fatalf("CompareAndSwap 1 failed: %#v", resp)
22 | 	}
23 | 
24 | 	if !(resp.PrevNode.Value == "bar" && resp.PrevNode.Key == "/foo" && resp.PrevNode.TTL == 5) {
25 | 		t.Fatalf("CompareAndSwap 1 prevNode failed: %#v", resp)
26 | 	}
27 | 
28 | 	// This should fail because it gives an incorrect prevValue
29 | 	resp, err = c.CompareAndSwap("foo", "bar3", 5, "xxx", 0)
30 | 	if err == nil {
31 | 		t.Fatalf("CompareAndSwap 2 should have failed.  The response is: %#v", resp)
32 | 	}
33 | 
34 | 	resp, err = c.Set("foo", "bar", 5)
35 | 	if err != nil {
36 | 		t.Fatal(err)
37 | 	}
38 | 
39 | 	// This should succeed
40 | 	resp, err = c.CompareAndSwap("foo", "bar2", 5, "", resp.Node.ModifiedIndex)
41 | 	if err != nil {
42 | 		t.Fatal(err)
43 | 	}
44 | 	if !(resp.Node.Value == "bar2" && resp.Node.Key == "/foo" && resp.Node.TTL == 5) {
45 | 		t.Fatalf("CompareAndSwap 3 failed: %#v", resp)
46 | 	}
47 | 
48 | 	if !(resp.PrevNode.Value == "bar" && resp.PrevNode.Key == "/foo" && resp.PrevNode.TTL == 5) {
49 | 		t.Fatalf("CompareAndSwap 3 prevNode failed: %#v", resp)
50 | 	}
51 | 
52 | 	// This should fail because it gives an incorrect prevIndex
53 | 	resp, err = c.CompareAndSwap("foo", "bar3", 5, "", 29817514)
54 | 	if err == nil {
55 | 		t.Fatalf("CompareAndSwap 4 should have failed.  The response is: %#v", resp)
56 | 	}
57 | }
58 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/debug.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import (
 4 | 	"os"
 5 | 
 6 | 	"github.com/coreos/go-log/log"
 7 | )
 8 | 
 9 | var logger *log.Logger
10 | 
11 | func init() {
12 | 	setLogger(log.PriErr)
13 | }
14 | 
15 | func OpenDebug() {
16 | 	setLogger(log.PriDebug)
17 | }
18 | 
19 | func CloseDebug() {
20 | 	setLogger(log.PriErr)
21 | }
22 | 
23 | func setLogger(priority log.Priority) {
24 | 	logger = log.NewSimple(
25 | 		log.PriorityFilter(
26 | 			priority,
27 | 			log.WriterSink(os.Stdout, log.BasicFormat, log.BasicFields)))
28 | }
29 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/delete.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | // Delete deletes the given key.
 4 | //
 5 | // When recursive set to false, if the key points to a
 6 | // directory the method will fail.
 7 | //
 8 | // When recursive set to true, if the key points to a file,
 9 | // the file will be deleted; if the key points to a directory,
10 | // then everything under the directory (including all child directories)
11 | // will be deleted.
12 | func (c *Client) Delete(key string, recursive bool) (*Response, error) {
13 | 	raw, err := c.DeleteRaw(key, recursive, false)
14 | 
15 | 	if err != nil {
16 | 		return nil, err
17 | 	}
18 | 
19 | 	return raw.toResponse()
20 | }
21 | 
22 | // DeleteDir deletes an empty directory or a key value pair
23 | func (c *Client) DeleteDir(key string) (*Response, error) {
24 | 	raw, err := c.DeleteRaw(key, false, true)
25 | 
26 | 	if err != nil {
27 | 		return nil, err
28 | 	}
29 | 
30 | 	return raw.toResponse()
31 | }
32 | 
33 | func (c *Client) DeleteRaw(key string, recursive bool, dir bool) (*RawResponse, error) {
34 | 	ops := options{
35 | 		"recursive": recursive,
36 | 		"dir":       dir,
37 | 	}
38 | 
39 | 	return c.delete(key, ops)
40 | }
41 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/delete_test.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import (
 4 | 	"testing"
 5 | )
 6 | 
 7 | func TestDelete(t *testing.T) {
 8 | 	c := NewClient(nil)
 9 | 	defer func() {
10 | 		c.Delete("foo", true)
11 | 	}()
12 | 
13 | 	c.Set("foo", "bar", 5)
14 | 	resp, err := c.Delete("foo", false)
15 | 	if err != nil {
16 | 		t.Fatal(err)
17 | 	}
18 | 
19 | 	if !(resp.Node.Value == "") {
20 | 		t.Fatalf("Delete failed with %s", resp.Node.Value)
21 | 	}
22 | 
23 | 	if !(resp.PrevNode.Value == "bar") {
24 | 		t.Fatalf("Delete PrevNode failed with %s", resp.Node.Value)
25 | 	}
26 | 
27 | 	resp, err = c.Delete("foo", false)
28 | 	if err == nil {
29 | 		t.Fatalf("Delete should have failed because the key foo did not exist.  "+
30 | 			"The response was: %v", resp)
31 | 	}
32 | }
33 | 
34 | func TestDeleteAll(t *testing.T) {
35 | 	c := NewClient(nil)
36 | 	defer func() {
37 | 		c.Delete("foo", true)
38 | 		c.Delete("fooDir", true)
39 | 	}()
40 | 
41 | 	c.SetDir("foo", 5)
42 | 	// test delete an empty dir
43 | 	resp, err := c.DeleteDir("foo")
44 | 	if err != nil {
45 | 		t.Fatal(err)
46 | 	}
47 | 
48 | 	if !(resp.Node.Value == "") {
49 | 		t.Fatalf("DeleteAll 1 failed: %#v", resp)
50 | 	}
51 | 
52 | 	if !(resp.PrevNode.Dir == true && resp.PrevNode.Value == "") {
53 | 		t.Fatalf("DeleteAll 1 PrevNode failed: %#v", resp)
54 | 	}
55 | 
56 | 	c.CreateDir("fooDir", 5)
57 | 	c.Set("fooDir/foo", "bar", 5)
58 | 	_, err = c.DeleteDir("fooDir")
59 | 	if err == nil {
60 | 		t.Fatal("should not able to delete a non-empty dir with deletedir")
61 | 	}
62 | 
63 | 	resp, err = c.Delete("fooDir", true)
64 | 	if err != nil {
65 | 		t.Fatal(err)
66 | 	}
67 | 
68 | 	if !(resp.Node.Value == "") {
69 | 		t.Fatalf("DeleteAll 2 failed: %#v", resp)
70 | 	}
71 | 
72 | 	if !(resp.PrevNode.Dir == true && resp.PrevNode.Value == "") {
73 | 		t.Fatalf("DeleteAll 2 PrevNode failed: %#v", resp)
74 | 	}
75 | 
76 | 	resp, err = c.Delete("foo", true)
77 | 	if err == nil {
78 | 		t.Fatalf("DeleteAll should have failed because the key foo did not exist.  "+
79 | 			"The response was: %v", resp)
80 | 	}
81 | }
82 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/error.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"fmt"
 6 | )
 7 | 
 8 | const (
 9 | 	ErrCodeEtcdNotReachable = 501
10 | )
11 | 
12 | var (
13 | 	errorMap = map[int]string{
14 | 		ErrCodeEtcdNotReachable: "All the given peers are not reachable",
15 | 	}
16 | )
17 | 
18 | type EtcdError struct {
19 | 	ErrorCode int    `json:"errorCode"`
20 | 	Message   string `json:"message"`
21 | 	Cause     string `json:"cause,omitempty"`
22 | 	Index     uint64 `json:"index"`
23 | }
24 | 
25 | func (e EtcdError) Error() string {
26 | 	return fmt.Sprintf("%v: %v (%v) [%v]", e.ErrorCode, e.Message, e.Cause, e.Index)
27 | }
28 | 
29 | func newError(errorCode int, cause string, index uint64) *EtcdError {
30 | 	return &EtcdError{
31 | 		ErrorCode: errorCode,
32 | 		Message:   errorMap[errorCode],
33 | 		Cause:     cause,
34 | 		Index:     index,
35 | 	}
36 | }
37 | 
38 | func handleError(b []byte) error {
39 | 	var err EtcdError
40 | 
41 | 	json.Unmarshal(b, &err)
42 | 
43 | 	return err
44 | }
45 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/get.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | // Get gets the file or directory associated with the given key.
 4 | // If the key points to a directory, files and directories under
 5 | // it will be returned in sorted or unsorted order, depending on
 6 | // the sort flag.
 7 | // If recursive is set to false, contents under child directories
 8 | // will not be returned.
 9 | // If recursive is set to true, all the contents will be returned.
10 | func (c *Client) Get(key string, sort, recursive bool) (*Response, error) {
11 | 	raw, err := c.RawGet(key, sort, recursive)
12 | 
13 | 	if err != nil {
14 | 		return nil, err
15 | 	}
16 | 
17 | 	return raw.toResponse()
18 | }
19 | 
20 | func (c *Client) RawGet(key string, sort, recursive bool) (*RawResponse, error) {
21 | 	ops := options{
22 | 		"recursive": recursive,
23 | 		"sorted":    sort,
24 | 	}
25 | 
26 | 	return c.get(key, ops)
27 | }
28 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/get_test.go:
--------------------------------------------------------------------------------
  1 | package etcd
  2 | 
  3 | import (
  4 | 	"reflect"
  5 | 	"testing"
  6 | )
  7 | 
  8 | func TestGet(t *testing.T) {
  9 | 	c := NewClient(nil)
 10 | 	defer func() {
 11 | 		c.Delete("foo", true)
 12 | 	}()
 13 | 
 14 | 	c.Set("foo", "bar", 5)
 15 | 
 16 | 	result, err := c.Get("foo", false, false)
 17 | 
 18 | 	if err != nil {
 19 | 		t.Fatal(err)
 20 | 	}
 21 | 
 22 | 	if result.Node.Key != "/foo" || result.Node.Value != "bar" {
 23 | 		t.Fatalf("Get failed with %s %s %v", result.Node.Key, result.Node.Value, result.Node.TTL)
 24 | 	}
 25 | 
 26 | 	result, err = c.Get("goo", false, false)
 27 | 	if err == nil {
 28 | 		t.Fatalf("should not be able to get non-exist key")
 29 | 	}
 30 | }
 31 | 
 32 | func TestGetAll(t *testing.T) {
 33 | 	c := NewClient(nil)
 34 | 	defer func() {
 35 | 		c.Delete("fooDir", true)
 36 | 	}()
 37 | 
 38 | 	c.CreateDir("fooDir", 5)
 39 | 	c.Set("fooDir/k0", "v0", 5)
 40 | 	c.Set("fooDir/k1", "v1", 5)
 41 | 
 42 | 	// Return kv-pairs in sorted order
 43 | 	result, err := c.Get("fooDir", true, false)
 44 | 
 45 | 	if err != nil {
 46 | 		t.Fatal(err)
 47 | 	}
 48 | 
 49 | 	expected := Nodes{
 50 | 		Node{
 51 | 			Key:           "/fooDir/k0",
 52 | 			Value:         "v0",
 53 | 			TTL:           5,
 54 | 			ModifiedIndex: 31,
 55 | 			CreatedIndex:  31,
 56 | 		},
 57 | 		Node{
 58 | 			Key:           "/fooDir/k1",
 59 | 			Value:         "v1",
 60 | 			TTL:           5,
 61 | 			ModifiedIndex: 32,
 62 | 			CreatedIndex:  32,
 63 | 		},
 64 | 	}
 65 | 
 66 | 	// do not check expiration time, too hard to fake
 67 | 	for i, _ := range result.Node.Nodes {
 68 | 		result.Node.Nodes[i].Expiration = nil
 69 | 	}
 70 | 
 71 | 	if !reflect.DeepEqual(result.Node.Nodes, expected) {
 72 | 		t.Fatalf("(actual) %v != (expected) %v", result.Node.Nodes, expected)
 73 | 	}
 74 | 
 75 | 	// Test the `recursive` option
 76 | 	c.CreateDir("fooDir/childDir", 5)
 77 | 	c.Set("fooDir/childDir/k2", "v2", 5)
 78 | 
 79 | 	// Return kv-pairs in sorted order
 80 | 	result, err = c.Get("fooDir", true, true)
 81 | 
 82 | 	// do not check expiration time, too hard to fake
 83 | 	result.Node.Expiration = nil
 84 | 	for i, _ := range result.Node.Nodes {
 85 | 		result.Node.Nodes[i].Expiration = nil
 86 | 		if result.Node.Nodes[i].Nodes != nil {
 87 | 			for j, _ := range result.Node.Nodes[i].Nodes {
 88 | 				result.Node.Nodes[i].Nodes[j].Expiration = nil
 89 | 			}
 90 | 		}
 91 | 	}
 92 | 
 93 | 	if err != nil {
 94 | 		t.Fatal(err)
 95 | 	}
 96 | 
 97 | 	expected = Nodes{
 98 | 		Node{
 99 | 			Key: "/fooDir/childDir",
100 | 			Dir: true,
101 | 			Nodes: Nodes{
102 | 				Node{
103 | 					Key:           "/fooDir/childDir/k2",
104 | 					Value:         "v2",
105 | 					TTL:           5,
106 | 					ModifiedIndex: 34,
107 | 					CreatedIndex:  34,
108 | 				},
109 | 			},
110 | 			TTL:           5,
111 | 			ModifiedIndex: 33,
112 | 			CreatedIndex:  33,
113 | 		},
114 | 		Node{
115 | 			Key:           "/fooDir/k0",
116 | 			Value:         "v0",
117 | 			TTL:           5,
118 | 			ModifiedIndex: 31,
119 | 			CreatedIndex:  31,
120 | 		},
121 | 		Node{
122 | 			Key:           "/fooDir/k1",
123 | 			Value:         "v1",
124 | 			TTL:           5,
125 | 			ModifiedIndex: 32,
126 | 			CreatedIndex:  32,
127 | 		},
128 | 	}
129 | 
130 | 	if !reflect.DeepEqual(result.Node.Nodes, expected) {
131 | 		t.Fatalf("(actual) %v != (expected) %v", result.Node.Nodes, expected)
132 | 	}
133 | }
134 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/options.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/url"
 6 | 	"reflect"
 7 | )
 8 | 
 9 | type options map[string]interface{}
10 | 
11 | // An internally-used data structure that represents a mapping
12 | // between valid options and their kinds
13 | type validOptions map[string]reflect.Kind
14 | 
15 | // Valid options for GET, PUT, POST, DELETE
16 | // Using CAPITALIZED_UNDERSCORE to emphasize that these
17 | // values are meant to be used as constants.
18 | var (
19 | 	VALID_GET_OPTIONS = validOptions{
20 | 		"recursive":  reflect.Bool,
21 | 		"consistent": reflect.Bool,
22 | 		"sorted":     reflect.Bool,
23 | 		"wait":       reflect.Bool,
24 | 		"waitIndex":  reflect.Uint64,
25 | 	}
26 | 
27 | 	VALID_PUT_OPTIONS = validOptions{
28 | 		"prevValue": reflect.String,
29 | 		"prevIndex": reflect.Uint64,
30 | 		"prevExist": reflect.Bool,
31 | 		"dir":       reflect.Bool,
32 | 	}
33 | 
34 | 	VALID_POST_OPTIONS = validOptions{}
35 | 
36 | 	VALID_DELETE_OPTIONS = validOptions{
37 | 		"recursive": reflect.Bool,
38 | 		"dir":       reflect.Bool,
39 | 	}
40 | )
41 | 
42 | // Convert options to a string of HTML parameters
43 | func (ops options) toParameters(validOps validOptions) (string, error) {
44 | 	p := "?"
45 | 	values := url.Values{}
46 | 
47 | 	if ops == nil {
48 | 		return "", nil
49 | 	}
50 | 
51 | 	for k, v := range ops {
52 | 		// Check if the given option is valid (that it exists)
53 | 		kind := validOps[k]
54 | 		if kind == reflect.Invalid {
55 | 			return "", fmt.Errorf("Invalid option: %v", k)
56 | 		}
57 | 
58 | 		// Check if the given option is of the valid type
59 | 		t := reflect.TypeOf(v)
60 | 		if kind != t.Kind() {
61 | 			return "", fmt.Errorf("Option %s should be of %v kind, not of %v kind.",
62 | 				k, kind, t.Kind())
63 | 		}
64 | 
65 | 		values.Set(k, fmt.Sprintf("%v", v))
66 | 	}
67 | 
68 | 	p += values.Encode()
69 | 	return p, nil
70 | }
71 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/requests.go:
--------------------------------------------------------------------------------
  1 | package etcd
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"io/ioutil"
  6 | 	"math/rand"
  7 | 	"net/http"
  8 | 	"net/url"
  9 | 	"path"
 10 | 	"strings"
 11 | 	"time"
 12 | )
 13 | 
 14 | // get issues a GET request
 15 | func (c *Client) get(key string, options options) (*RawResponse, error) {
 16 | 	logger.Debugf("get %s [%s]", key, c.cluster.Leader)
 17 | 	p := keyToPath(key)
 18 | 
 19 | 	// If consistency level is set to STRONG, append
 20 | 	// the `consistent` query string.
 21 | 	if c.config.Consistency == STRONG_CONSISTENCY {
 22 | 		options["consistent"] = true
 23 | 	}
 24 | 
 25 | 	str, err := options.toParameters(VALID_GET_OPTIONS)
 26 | 	if err != nil {
 27 | 		return nil, err
 28 | 	}
 29 | 	p += str
 30 | 
 31 | 	resp, err := c.sendRequest("GET", p, nil)
 32 | 
 33 | 	if err != nil {
 34 | 		return nil, err
 35 | 	}
 36 | 
 37 | 	return resp, nil
 38 | }
 39 | 
 40 | // put issues a PUT request
 41 | func (c *Client) put(key string, value string, ttl uint64,
 42 | 	options options) (*RawResponse, error) {
 43 | 
 44 | 	logger.Debugf("put %s, %s, ttl: %d, [%s]", key, value, ttl, c.cluster.Leader)
 45 | 	p := keyToPath(key)
 46 | 
 47 | 	str, err := options.toParameters(VALID_PUT_OPTIONS)
 48 | 	if err != nil {
 49 | 		return nil, err
 50 | 	}
 51 | 	p += str
 52 | 
 53 | 	resp, err := c.sendRequest("PUT", p, buildValues(value, ttl))
 54 | 
 55 | 	if err != nil {
 56 | 		return nil, err
 57 | 	}
 58 | 
 59 | 	return resp, nil
 60 | }
 61 | 
 62 | // post issues a POST request
 63 | func (c *Client) post(key string, value string, ttl uint64) (*RawResponse, error) {
 64 | 	logger.Debugf("post %s, %s, ttl: %d, [%s]", key, value, ttl, c.cluster.Leader)
 65 | 	p := keyToPath(key)
 66 | 
 67 | 	resp, err := c.sendRequest("POST", p, buildValues(value, ttl))
 68 | 
 69 | 	if err != nil {
 70 | 		return nil, err
 71 | 	}
 72 | 
 73 | 	return resp, nil
 74 | }
 75 | 
 76 | // delete issues a DELETE request
 77 | func (c *Client) delete(key string, options options) (*RawResponse, error) {
 78 | 	logger.Debugf("delete %s [%s]", key, c.cluster.Leader)
 79 | 	p := keyToPath(key)
 80 | 
 81 | 	str, err := options.toParameters(VALID_DELETE_OPTIONS)
 82 | 	if err != nil {
 83 | 		return nil, err
 84 | 	}
 85 | 	p += str
 86 | 
 87 | 	resp, err := c.sendRequest("DELETE", p, nil)
 88 | 
 89 | 	if err != nil {
 90 | 		return nil, err
 91 | 	}
 92 | 
 93 | 	return resp, nil
 94 | }
 95 | 
 96 | // sendRequest sends a HTTP request and returns a Response as defined by etcd
 97 | func (c *Client) sendRequest(method string, relativePath string,
 98 | 	values url.Values) (*RawResponse, error) {
 99 | 
100 | 	var req *http.Request
101 | 	var resp *http.Response
102 | 	var httpPath string
103 | 	var err error
104 | 	var b []byte
105 | 
106 | 	trial := 0
107 | 
108 | 	// if we connect to a follower, we will retry until we found a leader
109 | 	for {
110 | 		trial++
111 | 		logger.Debug("begin trail ", trial)
112 | 		if trial > 2*len(c.cluster.Machines) {
113 | 			return nil, newError(ErrCodeEtcdNotReachable,
114 | 				"Tried to connect to each peer twice and failed", 0)
115 | 		}
116 | 
117 | 		if method == "GET" && c.config.Consistency == WEAK_CONSISTENCY {
118 | 			// If it's a GET and consistency level is set to WEAK,
119 | 			// then use a random machine.
120 | 			httpPath = c.getHttpPath(true, relativePath)
121 | 		} else {
122 | 			// Else use the leader.
123 | 			httpPath = c.getHttpPath(false, relativePath)
124 | 		}
125 | 
126 | 		// Return a cURL command if curlChan is set
127 | 		if c.cURLch != nil {
128 | 			command := fmt.Sprintf("curl -X %s %s", method, httpPath)
129 | 			for key, value := range values {
130 | 				command += fmt.Sprintf(" -d %s=%s", key, value[0])
131 | 			}
132 | 			c.sendCURL(command)
133 | 		}
134 | 
135 | 		logger.Debug("send.request.to ", httpPath, " | method ", method)
136 | 
137 | 		if values == nil {
138 | 			req, _ = http.NewRequest(method, httpPath, nil)
139 | 		} else {
140 | 			req, _ = http.NewRequest(method, httpPath,
141 | 				strings.NewReader(values.Encode()))
142 | 
143 | 			req.Header.Set("Content-Type",
144 | 				"application/x-www-form-urlencoded; param=value")
145 | 		}
146 | 
147 | 		// network error, change a machine!
148 | 		if resp, err = c.httpClient.Do(req); err != nil {
149 | 			c.switchLeader(trial % len(c.cluster.Machines))
150 | 			time.Sleep(time.Millisecond * 200)
151 | 			continue
152 | 		}
153 | 
154 | 		if resp != nil {
155 | 			logger.Debug("recv.response.from ", httpPath)
156 | 
157 | 			var ok bool
158 | 			ok, b = c.handleResp(resp)
159 | 
160 | 			if !ok {
161 | 				continue
162 | 			}
163 | 
164 | 			logger.Debug("recv.success.", httpPath)
165 | 			break
166 | 		}
167 | 
168 | 		// should not reach here
169 | 		// err and resp should not be nil at the same time
170 | 		logger.Debug("error.from ", httpPath)
171 | 		return nil, err
172 | 	}
173 | 
174 | 	r := &RawResponse{
175 | 		StatusCode: resp.StatusCode,
176 | 		Body:       b,
177 | 		Header:     resp.Header,
178 | 	}
179 | 
180 | 	return r, nil
181 | }
182 | 
183 | // handleResp handles the responses from the etcd server
184 | // If status code is OK, read the http body and return it as byte array
185 | // If status code is TemporaryRedirect, update leader.
186 | // If status code is InternalServerError, sleep for 200ms.
187 | func (c *Client) handleResp(resp *http.Response) (bool, []byte) {
188 | 	defer resp.Body.Close()
189 | 
190 | 	code := resp.StatusCode
191 | 
192 | 	if code == http.StatusTemporaryRedirect {
193 | 		u, err := resp.Location()
194 | 
195 | 		if err != nil {
196 | 			logger.Warning(err)
197 | 		} else {
198 | 			c.updateLeader(u)
199 | 		}
200 | 
201 | 		return false, nil
202 | 
203 | 	} else if code == http.StatusInternalServerError {
204 | 		time.Sleep(time.Millisecond * 200)
205 | 
206 | 	} else if validHttpStatusCode[code] {
207 | 		b, err := ioutil.ReadAll(resp.Body)
208 | 
209 | 		if err != nil {
210 | 			return false, nil
211 | 		}
212 | 
213 | 		return true, b
214 | 	}
215 | 
216 | 	logger.Warning("bad status code ", resp.StatusCode)
217 | 	return false, nil
218 | }
219 | 
220 | func (c *Client) getHttpPath(random bool, s ...string) string {
221 | 	var machine string
222 | 	if random {
223 | 		machine = c.cluster.Machines[rand.Intn(len(c.cluster.Machines))]
224 | 	} else {
225 | 		machine = c.cluster.Leader
226 | 	}
227 | 
228 | 	fullPath := machine + "/" + version
229 | 	for _, seg := range s {
230 | 		fullPath = fullPath + "/" + seg
231 | 	}
232 | 
233 | 	return fullPath
234 | }
235 | 
236 | // buildValues builds a url.Values map according to the given value and ttl
237 | func buildValues(value string, ttl uint64) url.Values {
238 | 	v := url.Values{}
239 | 
240 | 	if value != "" {
241 | 		v.Set("value", value)
242 | 	}
243 | 
244 | 	if ttl > 0 {
245 | 		v.Set("ttl", fmt.Sprintf("%v", ttl))
246 | 	}
247 | 
248 | 	return v
249 | }
250 | 
251 | // convert key string to http path exclude version
252 | // for example: key[foo] -> path[keys/foo]
253 | // key[/] -> path[keys/]
254 | func keyToPath(key string) string {
255 | 	p := path.Join("keys", key)
256 | 
257 | 	// corner case: if key is "/" or "//" ect
258 | 	// path join will clear the tailing "/"
259 | 	// we need to add it back
260 | 	if p == "keys" {
261 | 		p = "keys/"
262 | 	}
263 | 
264 | 	return p
265 | }
266 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/response.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"net/http"
 6 | 	"strconv"
 7 | 	"time"
 8 | )
 9 | 
10 | const (
11 | 	rawResponse = iota
12 | 	normalResponse
13 | )
14 | 
15 | type responseType int
16 | 
17 | type RawResponse struct {
18 | 	StatusCode int
19 | 	Body       []byte
20 | 	Header     http.Header
21 | }
22 | 
23 | var (
24 | 	validHttpStatusCode = map[int]bool{
25 | 		http.StatusCreated:            true,
26 | 		http.StatusOK:                 true,
27 | 		http.StatusBadRequest:         true,
28 | 		http.StatusNotFound:           true,
29 | 		http.StatusPreconditionFailed: true,
30 | 		http.StatusForbidden:          true,
31 | 	}
32 | )
33 | 
34 | func (rr *RawResponse) toResponse() (*Response, error) {
35 | 	if rr.StatusCode != http.StatusOK && rr.StatusCode != http.StatusCreated {
36 | 		return nil, handleError(rr.Body)
37 | 	}
38 | 
39 | 	resp := new(Response)
40 | 
41 | 	err := json.Unmarshal(rr.Body, resp)
42 | 
43 | 	if err != nil {
44 | 		return nil, err
45 | 	}
46 | 
47 | 	// attach index and term to response
48 | 	resp.EtcdIndex, _ = strconv.ParseUint(rr.Header.Get("X-Etcd-Index"), 10, 64)
49 | 	resp.RaftIndex, _ = strconv.ParseUint(rr.Header.Get("X-Raft-Index"), 10, 64)
50 | 	resp.RaftTerm, _ = strconv.ParseUint(rr.Header.Get("X-Raft-Term"), 10, 64)
51 | 
52 | 	return resp, nil
53 | }
54 | 
55 | type Response struct {
56 | 	Action    string `json:"action"`
57 | 	Node      *Node  `json:"node"`
58 | 	PrevNode  *Node  `json:"prevNode,omitempty"`
59 | 	EtcdIndex uint64 `json:"etcdIndex"`
60 | 	RaftIndex uint64 `json:"raftIndex"`
61 | 	RaftTerm  uint64 `json:"raftTerm"`
62 | }
63 | 
64 | type Node struct {
65 | 	Key           string     `json:"key, omitempty"`
66 | 	Value         string     `json:"value,omitempty"`
67 | 	Dir           bool       `json:"dir,omitempty"`
68 | 	Expiration    *time.Time `json:"expiration,omitempty"`
69 | 	TTL           int64      `json:"ttl,omitempty"`
70 | 	Nodes         Nodes      `json:"nodes,omitempty"`
71 | 	ModifiedIndex uint64     `json:"modifiedIndex,omitempty"`
72 | 	CreatedIndex  uint64     `json:"createdIndex,omitempty"`
73 | }
74 | 
75 | type Nodes []Node
76 | 
77 | // interfaces for sorting
78 | func (ns Nodes) Len() int {
79 | 	return len(ns)
80 | }
81 | 
82 | func (ns Nodes) Less(i, j int) bool {
83 | 	return ns[i].Key < ns[j].Key
84 | }
85 | 
86 | func (ns Nodes) Swap(i, j int) {
87 | 	ns[i], ns[j] = ns[j], ns[i]
88 | }
89 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/set_curl_chan_test.go:
--------------------------------------------------------------------------------
 1 | package etcd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"testing"
 6 | )
 7 | 
 8 | func TestSetCurlChan(t *testing.T) {
 9 | 	c := NewClient(nil)
10 | 	c.OpenCURL()
11 | 
12 | 	defer func() {
13 | 		c.Delete("foo", true)
14 | 	}()
15 | 
16 | 	_, err := c.Set("foo", "bar", 5)
17 | 	if err != nil {
18 | 		t.Fatal(err)
19 | 	}
20 | 
21 | 	expected := fmt.Sprintf("curl -X PUT %s/v2/keys/foo -d value=bar -d ttl=5",
22 | 		c.cluster.Leader)
23 | 	actual := c.RecvCURL()
24 | 	if expected != actual {
25 | 		t.Fatalf(`Command "%s" is not equal to expected value "%s"`,
26 | 			actual, expected)
27 | 	}
28 | 
29 | 	c.SetConsistency(STRONG_CONSISTENCY)
30 | 	_, err = c.Get("foo", false, false)
31 | 	if err != nil {
32 | 		t.Fatal(err)
33 | 	}
34 | 
35 | 	expected = fmt.Sprintf("curl -X GET %s/v2/keys/foo?consistent=true&recursive=false&sorted=false",
36 | 		c.cluster.Leader)
37 | 	actual = c.RecvCURL()
38 | 	if expected != actual {
39 | 		t.Fatalf(`Command "%s" is not equal to expected value "%s"`,
40 | 			actual, expected)
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/set_update_create.go:
--------------------------------------------------------------------------------
  1 | package etcd
  2 | 
  3 | // Set sets the given key to the given value.
  4 | // It will create a new key value pair or replace the old one.
  5 | // It will not replace a existing directory.
  6 | func (c *Client) Set(key string, value string, ttl uint64) (*Response, error) {
  7 | 	raw, err := c.RawSet(key, value, ttl)
  8 | 
  9 | 	if err != nil {
 10 | 		return nil, err
 11 | 	}
 12 | 
 13 | 	return raw.toResponse()
 14 | }
 15 | 
 16 | // Set sets the given key to a directory.
 17 | // It will create a new directory or replace the old key value pair by a directory.
 18 | // It will not replace a existing directory.
 19 | func (c *Client) SetDir(key string, ttl uint64) (*Response, error) {
 20 | 	raw, err := c.RawSetDir(key, ttl)
 21 | 
 22 | 	if err != nil {
 23 | 		return nil, err
 24 | 	}
 25 | 
 26 | 	return raw.toResponse()
 27 | }
 28 | 
 29 | // CreateDir creates a directory. It succeeds only if
 30 | // the given key does not yet exist.
 31 | func (c *Client) CreateDir(key string, ttl uint64) (*Response, error) {
 32 | 	raw, err := c.RawCreateDir(key, ttl)
 33 | 
 34 | 	if err != nil {
 35 | 		return nil, err
 36 | 	}
 37 | 
 38 | 	return raw.toResponse()
 39 | }
 40 | 
 41 | // UpdateDir updates the given directory. It succeeds only if the
 42 | // given key already exists.
 43 | func (c *Client) UpdateDir(key string, ttl uint64) (*Response, error) {
 44 | 	raw, err := c.RawUpdateDir(key, ttl)
 45 | 
 46 | 	if err != nil {
 47 | 		return nil, err
 48 | 	}
 49 | 
 50 | 	return raw.toResponse()
 51 | }
 52 | 
 53 | // Create creates a file with the given value under the given key.  It succeeds
 54 | // only if the given key does not yet exist.
 55 | func (c *Client) Create(key string, value string, ttl uint64) (*Response, error) {
 56 | 	raw, err := c.RawCreate(key, value, ttl)
 57 | 
 58 | 	if err != nil {
 59 | 		return nil, err
 60 | 	}
 61 | 
 62 | 	return raw.toResponse()
 63 | }
 64 | 
 65 | // Update updates the given key to the given value.  It succeeds only if the
 66 | // given key already exists.
 67 | func (c *Client) Update(key string, value string, ttl uint64) (*Response, error) {
 68 | 	raw, err := c.RawUpdate(key, value, ttl)
 69 | 
 70 | 	if err != nil {
 71 | 		return nil, err
 72 | 	}
 73 | 
 74 | 	return raw.toResponse()
 75 | }
 76 | 
 77 | func (c *Client) RawUpdateDir(key string, ttl uint64) (*RawResponse, error) {
 78 | 	ops := options{
 79 | 		"prevExist": true,
 80 | 		"dir":       true,
 81 | 	}
 82 | 
 83 | 	return c.put(key, "", ttl, ops)
 84 | }
 85 | 
 86 | func (c *Client) RawCreateDir(key string, ttl uint64) (*RawResponse, error) {
 87 | 	ops := options{
 88 | 		"prevExist": false,
 89 | 		"dir":       true,
 90 | 	}
 91 | 
 92 | 	return c.put(key, "", ttl, ops)
 93 | }
 94 | 
 95 | func (c *Client) RawSet(key string, value string, ttl uint64) (*RawResponse, error) {
 96 | 	return c.put(key, value, ttl, nil)
 97 | }
 98 | 
 99 | func (c *Client) RawSetDir(key string, ttl uint64) (*RawResponse, error) {
100 | 	ops := options{
101 | 		"dir": true,
102 | 	}
103 | 
104 | 	return c.put(key, "", ttl, ops)
105 | }
106 | 
107 | func (c *Client) RawUpdate(key string, value string, ttl uint64) (*RawResponse, error) {
108 | 	ops := options{
109 | 		"prevExist": true,
110 | 	}
111 | 
112 | 	return c.put(key, value, ttl, ops)
113 | }
114 | 
115 | func (c *Client) RawCreate(key string, value string, ttl uint64) (*RawResponse, error) {
116 | 	ops := options{
117 | 		"prevExist": false,
118 | 	}
119 | 
120 | 	return c.put(key, value, ttl, ops)
121 | }
122 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/set_update_create_test.go:
--------------------------------------------------------------------------------
  1 | package etcd
  2 | 
  3 | import (
  4 | 	"testing"
  5 | )
  6 | 
  7 | func TestSet(t *testing.T) {
  8 | 	c := NewClient(nil)
  9 | 	defer func() {
 10 | 		c.Delete("foo", true)
 11 | 	}()
 12 | 
 13 | 	resp, err := c.Set("foo", "bar", 5)
 14 | 	if err != nil {
 15 | 		t.Fatal(err)
 16 | 	}
 17 | 	if resp.Node.Key != "/foo" || resp.Node.Value != "bar" || resp.Node.TTL != 5 {
 18 | 		t.Fatalf("Set 1 failed: %#v", resp)
 19 | 	}
 20 | 	if resp.PrevNode != nil {
 21 | 		t.Fatalf("Set 1 PrevNode failed: %#v", resp)
 22 | 	}
 23 | 
 24 | 	resp, err = c.Set("foo", "bar2", 5)
 25 | 	if err != nil {
 26 | 		t.Fatal(err)
 27 | 	}
 28 | 	if !(resp.Node.Key == "/foo" && resp.Node.Value == "bar2" && resp.Node.TTL == 5) {
 29 | 		t.Fatalf("Set 2 failed: %#v", resp)
 30 | 	}
 31 | 	if resp.PrevNode.Key != "/foo" || resp.PrevNode.Value != "bar" || resp.Node.TTL != 5 {
 32 | 		t.Fatalf("Set 2 PrevNode failed: %#v", resp)
 33 | 	}
 34 | }
 35 | 
 36 | func TestUpdate(t *testing.T) {
 37 | 	c := NewClient(nil)
 38 | 	defer func() {
 39 | 		c.Delete("foo", true)
 40 | 		c.Delete("nonexistent", true)
 41 | 	}()
 42 | 
 43 | 	resp, err := c.Set("foo", "bar", 5)
 44 | 
 45 | 	if err != nil {
 46 | 		t.Fatal(err)
 47 | 	}
 48 | 
 49 | 	// This should succeed.
 50 | 	resp, err = c.Update("foo", "wakawaka", 5)
 51 | 	if err != nil {
 52 | 		t.Fatal(err)
 53 | 	}
 54 | 
 55 | 	if !(resp.Action == "update" && resp.Node.Key == "/foo" && resp.Node.TTL == 5) {
 56 | 		t.Fatalf("Update 1 failed: %#v", resp)
 57 | 	}
 58 | 	if !(resp.PrevNode.Key == "/foo" && resp.PrevNode.Value == "bar" && resp.Node.TTL == 5) {
 59 | 		t.Fatalf("Update 1 prevValue failed: %#v", resp)
 60 | 	}
 61 | 
 62 | 	// This should fail because the key does not exist.
 63 | 	resp, err = c.Update("nonexistent", "whatever", 5)
 64 | 	if err == nil {
 65 | 		t.Fatalf("The key %v did not exist, so the update should have failed."+
 66 | 			"The response was: %#v", resp.Node.Key, resp)
 67 | 	}
 68 | }
 69 | 
 70 | func TestCreate(t *testing.T) {
 71 | 	c := NewClient(nil)
 72 | 	defer func() {
 73 | 		c.Delete("newKey", true)
 74 | 	}()
 75 | 
 76 | 	newKey := "/newKey"
 77 | 	newValue := "/newValue"
 78 | 
 79 | 	// This should succeed
 80 | 	resp, err := c.Create(newKey, newValue, 5)
 81 | 	if err != nil {
 82 | 		t.Fatal(err)
 83 | 	}
 84 | 
 85 | 	if !(resp.Action == "create" && resp.Node.Key == newKey &&
 86 | 		resp.Node.Value == newValue && resp.Node.TTL == 5) {
 87 | 		t.Fatalf("Create 1 failed: %#v", resp)
 88 | 	}
 89 | 	if resp.PrevNode != nil {
 90 | 		t.Fatalf("Create 1 PrevNode failed: %#v", resp)
 91 | 	}
 92 | 
 93 | 	// This should fail, because the key is already there
 94 | 	resp, err = c.Create(newKey, newValue, 5)
 95 | 	if err == nil {
 96 | 		t.Fatalf("The key %v did exist, so the creation should have failed."+
 97 | 			"The response was: %#v", resp.Node.Key, resp)
 98 | 	}
 99 | }
100 | 
101 | func TestSetDir(t *testing.T) {
102 | 	c := NewClient(nil)
103 | 	defer func() {
104 | 		c.Delete("foo", true)
105 | 		c.Delete("fooDir", true)
106 | 	}()
107 | 
108 | 	resp, err := c.CreateDir("fooDir", 5)
109 | 	if err != nil {
110 | 		t.Fatal(err)
111 | 	}
112 | 	if !(resp.Node.Key == "/fooDir" && resp.Node.Value == "" && resp.Node.TTL == 5) {
113 | 		t.Fatalf("SetDir 1 failed: %#v", resp)
114 | 	}
115 | 	if resp.PrevNode != nil {
116 | 		t.Fatalf("SetDir 1 PrevNode failed: %#v", resp)
117 | 	}
118 | 
119 | 	// This should fail because /fooDir already points to a directory
120 | 	resp, err = c.CreateDir("/fooDir", 5)
121 | 	if err == nil {
122 | 		t.Fatalf("fooDir already points to a directory, so SetDir should have failed."+
123 | 			"The response was: %#v", resp)
124 | 	}
125 | 
126 | 	_, err = c.Set("foo", "bar", 5)
127 | 	if err != nil {
128 | 		t.Fatal(err)
129 | 	}
130 | 
131 | 	// This should succeed
132 | 	// It should replace the key
133 | 	resp, err = c.SetDir("foo", 5)
134 | 	if err != nil {
135 | 		t.Fatal(err)
136 | 	}
137 | 	if !(resp.Node.Key == "/foo" && resp.Node.Value == "" && resp.Node.TTL == 5) {
138 | 		t.Fatalf("SetDir 2 failed: %#v", resp)
139 | 	}
140 | 	if !(resp.PrevNode.Key == "/foo" && resp.PrevNode.Value == "bar" && resp.PrevNode.TTL == 5) {
141 | 		t.Fatalf("SetDir 2 failed: %#v", resp)
142 | 	}
143 | }
144 | 
145 | func TestUpdateDir(t *testing.T) {
146 | 	c := NewClient(nil)
147 | 	defer func() {
148 | 		c.Delete("fooDir", true)
149 | 	}()
150 | 
151 | 	resp, err := c.CreateDir("fooDir", 5)
152 | 	if err != nil {
153 | 		t.Fatal(err)
154 | 	}
155 | 
156 | 	// This should succeed.
157 | 	resp, err = c.UpdateDir("fooDir", 5)
158 | 	if err != nil {
159 | 		t.Fatal(err)
160 | 	}
161 | 
162 | 	if !(resp.Action == "update" && resp.Node.Key == "/fooDir" &&
163 | 		resp.Node.Value == "" && resp.Node.TTL == 5) {
164 | 		t.Fatalf("UpdateDir 1 failed: %#v", resp)
165 | 	}
166 | 	if !(resp.PrevNode.Key == "/fooDir" && resp.PrevNode.Dir == true && resp.PrevNode.TTL == 5) {
167 | 		t.Fatalf("UpdateDir 1 PrevNode failed: %#v", resp)
168 | 	}
169 | 
170 | 	// This should fail because the key does not exist.
171 | 	resp, err = c.UpdateDir("nonexistentDir", 5)
172 | 	if err == nil {
173 | 		t.Fatalf("The key %v did not exist, so the update should have failed."+
174 | 			"The response was: %#v", resp.Node.Key, resp)
175 | 	}
176 | }
177 | 
178 | func TestCreateDir(t *testing.T) {
179 | 	c := NewClient(nil)
180 | 	defer func() {
181 | 		c.Delete("fooDir", true)
182 | 	}()
183 | 
184 | 	// This should succeed
185 | 	resp, err := c.CreateDir("fooDir", 5)
186 | 	if err != nil {
187 | 		t.Fatal(err)
188 | 	}
189 | 
190 | 	if !(resp.Action == "create" && resp.Node.Key == "/fooDir" &&
191 | 		resp.Node.Value == "" && resp.Node.TTL == 5) {
192 | 		t.Fatalf("CreateDir 1 failed: %#v", resp)
193 | 	}
194 | 	if resp.PrevNode != nil {
195 | 		t.Fatalf("CreateDir 1 PrevNode failed: %#v", resp)
196 | 	}
197 | 
198 | 	// This should fail, because the key is already there
199 | 	resp, err = c.CreateDir("fooDir", 5)
200 | 	if err == nil {
201 | 		t.Fatalf("The key %v did exist, so the creation should have failed."+
202 | 			"The response was: %#v", resp.Node.Key, resp)
203 | 	}
204 | }
205 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/version.go:
--------------------------------------------------------------------------------
1 | package etcd
2 | 
3 | const version = "v2"
4 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/watch.go:
--------------------------------------------------------------------------------
  1 | package etcd
  2 | 
  3 | import (
  4 | 	"errors"
  5 | )
  6 | 
  7 | // Errors introduced by the Watch command.
  8 | var (
  9 | 	ErrWatchStoppedByUser = errors.New("Watch stopped by the user via stop channel")
 10 | )
 11 | 
 12 | // If recursive is set to true the watch returns the first change under the given
 13 | // prefix since the given index.
 14 | //
 15 | // If recursive is set to false the watch returns the first change to the given key
 16 | // since the given index.
 17 | //
 18 | // To watch for the latest change, set waitIndex = 0.
 19 | //
 20 | // If a receiver channel is given, it will be a long-term watch. Watch will block at the
 21 | //channel. After someone receives the channel, it will go on to watch that
 22 | // prefix.  If a stop channel is given, the client can close long-term watch using
 23 | // the stop channel.
 24 | func (c *Client) Watch(prefix string, waitIndex uint64, recursive bool,
 25 | 	receiver chan *Response, stop chan bool) (*Response, error) {
 26 | 	logger.Debugf("watch %s [%s]", prefix, c.cluster.Leader)
 27 | 	if receiver == nil {
 28 | 		raw, err := c.watchOnce(prefix, waitIndex, recursive, stop)
 29 | 
 30 | 		if err != nil {
 31 | 			return nil, err
 32 | 		}
 33 | 
 34 | 		return raw.toResponse()
 35 | 	}
 36 | 
 37 | 	for {
 38 | 		raw, err := c.watchOnce(prefix, waitIndex, recursive, stop)
 39 | 
 40 | 		if err != nil {
 41 | 			return nil, err
 42 | 		}
 43 | 
 44 | 		resp, err := raw.toResponse()
 45 | 
 46 | 		if err != nil {
 47 | 			return nil, err
 48 | 		}
 49 | 
 50 | 		waitIndex = resp.Node.ModifiedIndex + 1
 51 | 		receiver <- resp
 52 | 	}
 53 | 
 54 | 	return nil, nil
 55 | }
 56 | 
 57 | func (c *Client) RawWatch(prefix string, waitIndex uint64, recursive bool,
 58 | 	receiver chan *RawResponse, stop chan bool) (*RawResponse, error) {
 59 | 
 60 | 	logger.Debugf("rawWatch %s [%s]", prefix, c.cluster.Leader)
 61 | 	if receiver == nil {
 62 | 		return c.watchOnce(prefix, waitIndex, recursive, stop)
 63 | 	}
 64 | 
 65 | 	for {
 66 | 		raw, err := c.watchOnce(prefix, waitIndex, recursive, stop)
 67 | 
 68 | 		if err != nil {
 69 | 			return nil, err
 70 | 		}
 71 | 
 72 | 		resp, err := raw.toResponse()
 73 | 
 74 | 		if err != nil {
 75 | 			return nil, err
 76 | 		}
 77 | 
 78 | 		waitIndex = resp.Node.ModifiedIndex + 1
 79 | 		receiver <- raw
 80 | 	}
 81 | 
 82 | 	return nil, nil
 83 | }
 84 | 
 85 | // helper func
 86 | // return when there is change under the given prefix
 87 | func (c *Client) watchOnce(key string, waitIndex uint64, recursive bool, stop chan bool) (*RawResponse, error) {
 88 | 
 89 | 	respChan := make(chan *RawResponse, 1)
 90 | 	errChan := make(chan error)
 91 | 
 92 | 	go func() {
 93 | 		options := options{
 94 | 			"wait": true,
 95 | 		}
 96 | 		if waitIndex > 0 {
 97 | 			options["waitIndex"] = waitIndex
 98 | 		}
 99 | 		if recursive {
100 | 			options["recursive"] = true
101 | 		}
102 | 
103 | 		resp, err := c.get(key, options)
104 | 
105 | 		if err != nil {
106 | 			errChan <- err
107 | 			return
108 | 		}
109 | 
110 | 		respChan <- resp
111 | 	}()
112 | 
113 | 	select {
114 | 	case resp := <-respChan:
115 | 		return resp, nil
116 | 	case err := <-errChan:
117 | 		return nil, err
118 | 	case <-stop:
119 | 		return nil, ErrWatchStoppedByUser
120 | 	}
121 | }
122 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-etcd/etcd/watch_test.go:
--------------------------------------------------------------------------------
  1 | package etcd
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"testing"
  6 | 	"time"
  7 | )
  8 | 
  9 | func TestWatch(t *testing.T) {
 10 | 	c := NewClient(nil)
 11 | 	defer func() {
 12 | 		c.Delete("watch_foo", true)
 13 | 	}()
 14 | 
 15 | 	go setHelper("watch_foo", "bar", c)
 16 | 
 17 | 	resp, err := c.Watch("watch_foo", 0, false, nil, nil)
 18 | 	if err != nil {
 19 | 		t.Fatal(err)
 20 | 	}
 21 | 	if !(resp.Node.Key == "/watch_foo" && resp.Node.Value == "bar") {
 22 | 		t.Fatalf("Watch 1 failed: %#v", resp)
 23 | 	}
 24 | 
 25 | 	go setHelper("watch_foo", "bar", c)
 26 | 
 27 | 	resp, err = c.Watch("watch_foo", resp.Node.ModifiedIndex+1, false, nil, nil)
 28 | 	if err != nil {
 29 | 		t.Fatal(err)
 30 | 	}
 31 | 	if !(resp.Node.Key == "/watch_foo" && resp.Node.Value == "bar") {
 32 | 		t.Fatalf("Watch 2 failed: %#v", resp)
 33 | 	}
 34 | 
 35 | 	ch := make(chan *Response, 10)
 36 | 	stop := make(chan bool, 1)
 37 | 
 38 | 	go setLoop("watch_foo", "bar", c)
 39 | 
 40 | 	go receiver(ch, stop)
 41 | 
 42 | 	_, err = c.Watch("watch_foo", 0, false, ch, stop)
 43 | 	if err != ErrWatchStoppedByUser {
 44 | 		t.Fatalf("Watch returned a non-user stop error")
 45 | 	}
 46 | }
 47 | 
 48 | func TestWatchAll(t *testing.T) {
 49 | 	c := NewClient(nil)
 50 | 	defer func() {
 51 | 		c.Delete("watch_foo", true)
 52 | 	}()
 53 | 
 54 | 	go setHelper("watch_foo/foo", "bar", c)
 55 | 
 56 | 	resp, err := c.Watch("watch_foo", 0, true, nil, nil)
 57 | 	if err != nil {
 58 | 		t.Fatal(err)
 59 | 	}
 60 | 	if !(resp.Node.Key == "/watch_foo/foo" && resp.Node.Value == "bar") {
 61 | 		t.Fatalf("WatchAll 1 failed: %#v", resp)
 62 | 	}
 63 | 
 64 | 	go setHelper("watch_foo/foo", "bar", c)
 65 | 
 66 | 	resp, err = c.Watch("watch_foo", resp.Node.ModifiedIndex+1, true, nil, nil)
 67 | 	if err != nil {
 68 | 		t.Fatal(err)
 69 | 	}
 70 | 	if !(resp.Node.Key == "/watch_foo/foo" && resp.Node.Value == "bar") {
 71 | 		t.Fatalf("WatchAll 2 failed: %#v", resp)
 72 | 	}
 73 | 
 74 | 	ch := make(chan *Response, 10)
 75 | 	stop := make(chan bool, 1)
 76 | 
 77 | 	go setLoop("watch_foo/foo", "bar", c)
 78 | 
 79 | 	go receiver(ch, stop)
 80 | 
 81 | 	_, err = c.Watch("watch_foo", 0, true, ch, stop)
 82 | 	if err != ErrWatchStoppedByUser {
 83 | 		t.Fatalf("Watch returned a non-user stop error")
 84 | 	}
 85 | }
 86 | 
 87 | func setHelper(key, value string, c *Client) {
 88 | 	time.Sleep(time.Second)
 89 | 	c.Set(key, value, 100)
 90 | }
 91 | 
 92 | func setLoop(key, value string, c *Client) {
 93 | 	time.Sleep(time.Second)
 94 | 	for i := 0; i < 10; i++ {
 95 | 		newValue := fmt.Sprintf("%s_%v", value, i)
 96 | 		c.Set(key, newValue, 100)
 97 | 		time.Sleep(time.Second / 10)
 98 | 	}
 99 | }
100 | 
101 | func receiver(c chan *Response, stop chan bool) {
102 | 	for i := 0; i < 10; i++ {
103 | 		<-c
104 | 	}
105 | 	stop <- true
106 | }
107 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-log/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | 
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 | 
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 | 
20 | _testmain.go
21 | 
22 | *.exe
23 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-log/LICENSE:
--------------------------------------------------------------------------------
  1 | Apache License
  2 | Version 2.0, January 2004
  3 | http://www.apache.org/licenses/
  4 | 
  5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 | 1. Definitions.
  8 | 
  9 | "License" shall mean the terms and conditions for use, reproduction, and
 10 | distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 | "Licensor" shall mean the copyright owner or entity authorized by the copyright
 13 | owner that is granting the License.
 14 | 
 15 | "Legal Entity" shall mean the union of the acting entity and all other entities
 16 | that control, are controlled by, or are under common control with that entity.
 17 | For the purposes of this definition, "control" means (i) the power, direct or
 18 | indirect, to cause the direction or management of such entity, whether by
 19 | contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
 20 | outstanding shares, or (iii) beneficial ownership of such entity.
 21 | 
 22 | "You" (or "Your") shall mean an individual or Legal Entity exercising
 23 | permissions granted by this License.
 24 | 
 25 | "Source" form shall mean the preferred form for making modifications, including
 26 | but not limited to software source code, documentation source, and configuration
 27 | files.
 28 | 
 29 | "Object" form shall mean any form resulting from mechanical transformation or
 30 | translation of a Source form, including but not limited to compiled object code,
 31 | generated documentation, and conversions to other media types.
 32 | 
 33 | "Work" shall mean the work of authorship, whether in Source or Object form, made
 34 | available under the License, as indicated by a copyright notice that is included
 35 | in or attached to the work (an example is provided in the Appendix below).
 36 | 
 37 | "Derivative Works" shall mean any work, whether in Source or Object form, that
 38 | is based on (or derived from) the Work and for which the editorial revisions,
 39 | annotations, elaborations, or other modifications represent, as a whole, an
 40 | original work of authorship. For the purposes of this License, Derivative Works
 41 | shall not include works that remain separable from, or merely link (or bind by
 42 | name) to the interfaces of, the Work and Derivative Works thereof.
 43 | 
 44 | "Contribution" shall mean any work of authorship, including the original version
 45 | of the Work and any modifications or additions to that Work or Derivative Works
 46 | thereof, that is intentionally submitted to Licensor for inclusion in the Work
 47 | by the copyright owner or by an individual or Legal Entity authorized to submit
 48 | on behalf of the copyright owner. For the purposes of this definition,
 49 | "submitted" means any form of electronic, verbal, or written communication sent
 50 | to the Licensor or its representatives, including but not limited to
 51 | communication on electronic mailing lists, source code control systems, and
 52 | issue tracking systems that are managed by, or on behalf of, the Licensor for
 53 | the purpose of discussing and improving the Work, but excluding communication
 54 | that is conspicuously marked or otherwise designated in writing by the copyright
 55 | owner as "Not a Contribution."
 56 | 
 57 | "Contributor" shall mean Licensor and any individual or Legal Entity on behalf
 58 | of whom a Contribution has been received by Licensor and subsequently
 59 | incorporated within the Work.
 60 | 
 61 | 2. Grant of Copyright License.
 62 | 
 63 | Subject to the terms and conditions of this License, each Contributor hereby
 64 | grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 65 | irrevocable copyright license to reproduce, prepare Derivative Works of,
 66 | publicly display, publicly perform, sublicense, and distribute the Work and such
 67 | Derivative Works in Source or Object form.
 68 | 
 69 | 3. Grant of Patent License.
 70 | 
 71 | Subject to the terms and conditions of this License, each Contributor hereby
 72 | grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 73 | irrevocable (except as stated in this section) patent license to make, have
 74 | made, use, offer to sell, sell, import, and otherwise transfer the Work, where
 75 | such license applies only to those patent claims licensable by such Contributor
 76 | that are necessarily infringed by their Contribution(s) alone or by combination
 77 | of their Contribution(s) with the Work to which such Contribution(s) was
 78 | submitted. If You institute patent litigation against any entity (including a
 79 | cross-claim or counterclaim in a lawsuit) alleging that the Work or a
 80 | Contribution incorporated within the Work constitutes direct or contributory
 81 | patent infringement, then any patent licenses granted to You under this License
 82 | for that Work shall terminate as of the date such litigation is filed.
 83 | 
 84 | 4. Redistribution.
 85 | 
 86 | You may reproduce and distribute copies of the Work or Derivative Works thereof
 87 | in any medium, with or without modifications, and in Source or Object form,
 88 | provided that You meet the following conditions:
 89 | 
 90 | You must give any other recipients of the Work or Derivative Works a copy of
 91 | this License; and
 92 | You must cause any modified files to carry prominent notices stating that You
 93 | changed the files; and
 94 | You must retain, in the Source form of any Derivative Works that You distribute,
 95 | all copyright, patent, trademark, and attribution notices from the Source form
 96 | of the Work, excluding those notices that do not pertain to any part of the
 97 | Derivative Works; and
 98 | If the Work includes a "NOTICE" text file as part of its distribution, then any
 99 | Derivative Works that You distribute must include a readable copy of the
100 | attribution notices contained within such NOTICE file, excluding those notices
101 | that do not pertain to any part of the Derivative Works, in at least one of the
102 | following places: within a NOTICE text file distributed as part of the
103 | Derivative Works; within the Source form or documentation, if provided along
104 | with the Derivative Works; or, within a display generated by the Derivative
105 | Works, if and wherever such third-party notices normally appear. The contents of
106 | the NOTICE file are for informational purposes only and do not modify the
107 | License. You may add Your own attribution notices within Derivative Works that
108 | You distribute, alongside or as an addendum to the NOTICE text from the Work,
109 | provided that such additional attribution notices cannot be construed as
110 | modifying the License.
111 | You may add Your own copyright statement to Your modifications and may provide
112 | additional or different license terms and conditions for use, reproduction, or
113 | distribution of Your modifications, or for any such Derivative Works as a whole,
114 | provided Your use, reproduction, and distribution of the Work otherwise complies
115 | with the conditions stated in this License.
116 | 
117 | 5. Submission of Contributions.
118 | 
119 | Unless You explicitly state otherwise, any Contribution intentionally submitted
120 | for inclusion in the Work by You to the Licensor shall be under the terms and
121 | conditions of this License, without any additional terms or conditions.
122 | Notwithstanding the above, nothing herein shall supersede or modify the terms of
123 | any separate license agreement you may have executed with Licensor regarding
124 | such Contributions.
125 | 
126 | 6. Trademarks.
127 | 
128 | This License does not grant permission to use the trade names, trademarks,
129 | service marks, or product names of the Licensor, except as required for
130 | reasonable and customary use in describing the origin of the Work and
131 | reproducing the content of the NOTICE file.
132 | 
133 | 7. Disclaimer of Warranty.
134 | 
135 | Unless required by applicable law or agreed to in writing, Licensor provides the
136 | Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
137 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
138 | including, without limitation, any warranties or conditions of TITLE,
139 | NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
140 | solely responsible for determining the appropriateness of using or
141 | redistributing the Work and assume any risks associated with Your exercise of
142 | permissions under this License.
143 | 
144 | 8. Limitation of Liability.
145 | 
146 | In no event and under no legal theory, whether in tort (including negligence),
147 | contract, or otherwise, unless required by applicable law (such as deliberate
148 | and grossly negligent acts) or agreed to in writing, shall any Contributor be
149 | liable to You for damages, including any direct, indirect, special, incidental,
150 | or consequential damages of any character arising as a result of this License or
151 | out of the use or inability to use the Work (including but not limited to
152 | damages for loss of goodwill, work stoppage, computer failure or malfunction, or
153 | any and all other commercial damages or losses), even if such Contributor has
154 | been advised of the possibility of such damages.
155 | 
156 | 9. Accepting Warranty or Additional Liability.
157 | 
158 | While redistributing the Work or Derivative Works thereof, You may choose to
159 | offer, and charge a fee for, acceptance of support, warranty, indemnity, or
160 | other liability obligations and/or rights consistent with this License. However,
161 | in accepting such obligations, You may act only on Your own behalf and on Your
162 | sole responsibility, not on behalf of any other Contributor, and only if You
163 | agree to indemnify, defend, and hold each Contributor harmless for any liability
164 | incurred by, or claims asserted against, such Contributor by reason of your
165 | accepting any such warranty or additional liability.
166 | 
167 | END OF TERMS AND CONDITIONS
168 | 
169 | APPENDIX: How to apply the Apache License to your work
170 | 
171 | To apply the Apache License to your work, attach the following boilerplate
172 | notice, with the fields enclosed by brackets "[]" replaced with your own
173 | identifying information. (Don't include the brackets!) The text should be
174 | enclosed in the appropriate comment syntax for the file format. We also
175 | recommend that a file or class name and description of purpose be included on
176 | the same "printed page" as the copyright notice for easier identification within
177 | third-party archives.
178 | 
179 |    Copyright [yyyy] [name of copyright owner]
180 | 
181 |    Licensed under the Apache License, Version 2.0 (the "License");
182 |    you may not use this file except in compliance with the License.
183 |    You may obtain a copy of the License at
184 | 
185 |      http://www.apache.org/licenses/LICENSE-2.0
186 | 
187 |    Unless required by applicable law or agreed to in writing, software
188 |    distributed under the License is distributed on an "AS IS" BASIS,
189 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
190 |    See the License for the specific language governing permissions and
191 |    limitations under the License.
192 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-log/README.md:
--------------------------------------------------------------------------------
  1 | go-log
  2 | ==========
  3 | 
  4 | go-log is a simple logging library for Go which supports logging to
  5 | systemd.
  6 | 
  7 | ### Examples
  8 | #### Default
  9 | This example uses the default log to log to standard out and (if available) to systemd:
 10 | ```go
 11 | package main
 12 | import (
 13 | 	"github.com/coreos/go-log/log"
 14 | )
 15 | 
 16 | func main() {
 17 | 	log.Info("Hello World.")
 18 | 	log.Error("There's nothing more to this program.")
 19 | }
 20 | ```
 21 | 
 22 | #### Using Sinks and Formats
 23 | ```go
 24 | package main
 25 | 
 26 | import (
 27 | 	"github.com/coreos/go-log/log"
 28 | 	"os"
 29 | )
 30 | 
 31 | func main() {
 32 | 	l := log.NewSimple(
 33 | 		log.WriterSink(os.Stderr,
 34 | 			"%s: %s[%d] %s\n",
 35 | 			[]string{"priority", "executable", "pid", "message"}))
 36 | 	l.Info("Here's a differently formatted log message.")
 37 | }
 38 | ```
 39 | 
 40 | #### Custom Sink
 41 | This example only logs messages with priority `PriErr` and greater.
 42 | ```go
 43 | package main
 44 | 
 45 | import (
 46 | 	"github.com/coreos/go-log/log"
 47 | 	"os"
 48 | )
 49 | 
 50 | func main() {
 51 | 	l := log.NewSimple(
 52 | 		&PriorityFilter{
 53 | 			log.PriErr,
 54 | 			log.WriterSink(os.Stdout, log.BasicFormat, log.BasicFields),
 55 | 		})
 56 | 	l.Info("This will be filtered out")
 57 | 	l.Info("and not printed at all.")
 58 | 	l.Error("This will be printed, though!")
 59 | 	l.Critical("And so will this!")
 60 | }
 61 | 
 62 | type PriorityFilter struct {
 63 | 	priority log.Priority
 64 | 	target   log.Sink
 65 | }
 66 | 
 67 | func (filter *PriorityFilter) Log(fields log.Fields) {
 68 | 	// lower priority values indicate more important messages
 69 | 	if fields["priority"].(log.Priority) <= filter.priority {
 70 | 		filter.target.Log(fields)
 71 | 	}
 72 | }
 73 | ```
 74 | 
 75 | ### Fields
 76 | The following fields are available for use in all sinks:
 77 | ```go
 78 | "prefix"       string              // static field available to all sinks
 79 | "seq"          uint64              // auto-incrementing sequence number
 80 | "start_time"   time.Time           // start time of the log
 81 | "time"         string              // formatted time of log entry
 82 | "full_time"    time.Time           // time of log entry
 83 | "rtime"        time.Duration       // relative time of log entry since started
 84 | "pid"          int                 // process id
 85 | "executable"   string              // executable filename
 86 | ```
 87 | In addition, if `verbose=true` is passed to `New()`, the following (somewhat expensive) runtime fields are also available:
 88 | ```go
 89 | "funcname"     string              // function name where the log function was called
 90 | "lineno"       int                 // line number where the log function was called
 91 | "pathname"     string              // full pathname of caller
 92 | "filename"     string              // filename of caller
 93 | ```
 94 | 
 95 | ### Logging functions
 96 | All these functions can also be called directly to use the default log.
 97 | ```go
 98 | func (*Logger) Log(priority Priority, v ...interface)
 99 | func (*Logger) Logf(priority Priority, format string, v ...interface{})
100 | func (*Logger) Emergency(v ...interface)
101 | func (*Logger) Emergencyf(format string, v ...interface{})
102 | func (*Logger) Alert(v ...interface)
103 | func (*Logger) Alertf(format string, v ...interface{})
104 | func (*Logger) Critical(v ...interface)
105 | func (*Logger) Criticalf(format string, v ...interface{})
106 | func (*Logger) Error(v ...interface)
107 | func (*Logger) Errorf(format string, v ...interface{})
108 | func (*Logger) Warning(v ...interface)
109 | func (*Logger) Warningf(format string, v ...interface{})
110 | func (*Logger) Notice(v ...interface)
111 | func (*Logger) Noticef(format string, v ...interface{})
112 | func (*Logger) Info(v ...interface)
113 | func (*Logger) Infof(format string, v ...interface{})
114 | func (*Logger) Debug(v ...interface)
115 | func (*Logger) Debugf(format string, v ...interface{})
116 | ```
117 | 
118 | ### Acknowledgements
119 | This package is a mostly-from-scratch rewrite of
120 | [ccding/go-logging](https://github.com/ccding/go-logging) with some features
121 | removed and systemd support added. 
122 | 
123 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-log/log/commands.go:
--------------------------------------------------------------------------------
  1 | package log
  2 | // Copyright 2013, CoreOS, Inc. All rights reserved.
  3 | //
  4 | // Licensed under the Apache License, Version 2.0 (the "License");
  5 | // you may not use this file except in compliance with the License.
  6 | // You may obtain a copy of the License at
  7 | //
  8 | //   http://www.apache.org/licenses/LICENSE-2.0
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software
 11 | // distributed under the License is distributed on an "AS IS" BASIS,
 12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | // See the License for the specific language governing permissions and
 14 | // limitations under the License.
 15 | //
 16 | // author: David Fisher <ddf1991@gmail.com>
 17 | // based on previous package by: Cong Ding <dinggnu@gmail.com>
 18 | 
 19 | import (
 20 | 	"fmt"
 21 | 	"os"
 22 | )
 23 | 
 24 | var BasicFormat = "%s [%9s] %s- %s\n"
 25 | var BasicFields = []string{"time", "priority", "prefix", "message"}
 26 | var RichFormat = "%s [%9s] %d %s - %s:%s:%d - %s\n"
 27 | var RichFields = []string{"full_time", "priority", "seq", "prefix", "filename", "funcname", "lineno", "message"}
 28 | 
 29 | // This function has an unusual name to aid in finding it while walking the
 30 | // stack. We need to do some dead reckoning from this function to access the
 31 | // caller's stack, so there is a consistent call depth above this function.
 32 | func (logger *Logger) Log(priority Priority, v ...interface{}) {
 33 | 	fields := logger.fieldValues()
 34 | 	fields["priority"] = priority
 35 | 	fields["message"] = fmt.Sprint(v...)
 36 | 	for _, sink := range logger.sinks {
 37 | 		sink.Log(fields)
 38 | 	}
 39 | }
 40 | 
 41 | func (logger *Logger) Logf(priority Priority, format string, v ...interface{}) {
 42 | 	logger.Log(priority, fmt.Sprintf(format, v...))
 43 | }
 44 | 
 45 | 
 46 | func (logger *Logger) Emergency(v ...interface{}) {
 47 | 	logger.Log(PriEmerg, v...)
 48 | }
 49 | func (logger *Logger) Emergencyf(format string, v ...interface{}) {
 50 | 	logger.Log(PriEmerg, fmt.Sprintf(format, v...))
 51 | }
 52 | 
 53 | func (logger *Logger) Alert(v ...interface{}) {
 54 | 	logger.Log(PriAlert, v...)
 55 | }
 56 | func (logger *Logger) Alertf(format string, v ...interface{}) {
 57 | 	logger.Log(PriAlert, fmt.Sprintf(format, v...))
 58 | }
 59 | 
 60 | func (logger *Logger) Critical(v ...interface{}) {
 61 | 	logger.Log(PriCrit, v...)
 62 | }
 63 | func (logger *Logger) Criticalf(format string, v ...interface{}) {
 64 | 	logger.Log(PriCrit, fmt.Sprintf(format, v...))
 65 | }
 66 | 
 67 | func (logger *Logger) Error(v ...interface{}) {
 68 | 	logger.Log(PriErr, v...)
 69 | }
 70 | func (logger *Logger) Errorf(format string, v ...interface{}) {
 71 | 	logger.Log(PriErr, fmt.Sprintf(format, v...))
 72 | }
 73 | 
 74 | func (logger *Logger) Warning(v ...interface{}) {
 75 | 	logger.Log(PriWarning, v...)
 76 | }
 77 | func (logger *Logger) Warningf(format string, v ...interface{}) {
 78 | 	logger.Log(PriWarning, fmt.Sprintf(format, v...))
 79 | }
 80 | 
 81 | func (logger *Logger) Notice(v ...interface{}) {
 82 | 	logger.Log(PriNotice, v...)
 83 | }
 84 | func (logger *Logger) Noticef(format string, v ...interface{}) {
 85 | 	logger.Log(PriNotice, fmt.Sprintf(format, v...))
 86 | }
 87 | 
 88 | func (logger *Logger) Info(v ...interface{}) {
 89 | 	logger.Log(PriInfo, v...)
 90 | }
 91 | func (logger *Logger) Infof(format string, v ...interface{}) {
 92 | 	logger.Log(PriInfo, fmt.Sprintf(format, v...))
 93 | }
 94 | 
 95 | func (logger *Logger) Debug(v ...interface{}) {
 96 | 	logger.Log(PriDebug, v...)
 97 | }
 98 | func (logger *Logger) Debugf(format string, v ...interface{}) {
 99 | 	logger.Log(PriDebug, fmt.Sprintf(format, v...))
100 | }
101 | 
102 | 
103 | func Emergency(v ...interface{}) {
104 | 	defaultLogger.Log(PriEmerg, v...)
105 | }
106 | func Emergencyf(format string, v ...interface{}) {
107 | 	defaultLogger.Log(PriEmerg, fmt.Sprintf(format, v...))
108 | }
109 | 
110 | func Alert(v ...interface{}) {
111 | 	defaultLogger.Log(PriAlert, v...)
112 | }
113 | func Alertf(format string, v ...interface{}) {
114 | 	defaultLogger.Log(PriAlert, fmt.Sprintf(format, v...))
115 | }
116 | 
117 | func Critical(v ...interface{}) {
118 | 	defaultLogger.Log(PriCrit, v...)
119 | }
120 | func Criticalf(format string, v ...interface{}) {
121 | 	defaultLogger.Log(PriCrit, fmt.Sprintf(format, v...))
122 | }
123 | 
124 | func Error(v ...interface{}) {
125 | 	defaultLogger.Log(PriErr, v...)
126 | }
127 | func Errorf(format string, v ...interface{}) {
128 | 	defaultLogger.Log(PriErr, fmt.Sprintf(format, v...))
129 | }
130 | 
131 | func Warning(v ...interface{}) {
132 | 	defaultLogger.Log(PriWarning, v...)
133 | }
134 | func Warningf(format string, v ...interface{}) {
135 | 	defaultLogger.Log(PriWarning, fmt.Sprintf(format, v...))
136 | }
137 | 
138 | func Notice(v ...interface{}) {
139 | 	defaultLogger.Log(PriNotice, v...)
140 | }
141 | func Noticef(format string, v ...interface{}) {
142 | 	defaultLogger.Log(PriNotice, fmt.Sprintf(format, v...))
143 | }
144 | 
145 | func Info(v ...interface{}) {
146 | 	defaultLogger.Log(PriInfo, v...)
147 | }
148 | func Infof(format string, v ...interface{}) {
149 | 	defaultLogger.Log(PriInfo, fmt.Sprintf(format, v...))
150 | }
151 | 
152 | func Debug(v ...interface{}) {
153 | 	defaultLogger.Log(PriDebug, v...)
154 | }
155 | func Debugf(format string, v ...interface{}) {
156 | 	defaultLogger.Log(PriDebug, fmt.Sprintf(format, v...))
157 | }
158 | 
159 | // Standard library log functions
160 | 
161 | func (logger *Logger)Fatalln (v ...interface{}) {
162 | 	logger.Log(PriCrit, v...)
163 | 	os.Exit(1)
164 | }
165 | func (logger *Logger)Fatalf (format string, v ...interface{}) {
166 | 	logger.Logf(PriCrit, format, v...)
167 | 	os.Exit(1)
168 | }
169 | 
170 | func (logger *Logger)Panicln (v ...interface{}) {
171 | 	s := fmt.Sprint(v...)
172 | 	logger.Log(PriErr, s)
173 | 	panic(s)
174 | }
175 | func (logger *Logger)Panicf (format string, v ...interface{}) {
176 | 	s := fmt.Sprintf(format, v...)
177 | 	logger.Log(PriErr, s)
178 | 	panic(s)
179 | }
180 | 
181 | func (logger *Logger)Println (v ...interface{}) {
182 | 	logger.Log(PriInfo, v...)
183 | }
184 | func (logger *Logger)Printf (format string, v ...interface{}) {
185 | 	logger.Logf(PriInfo, format, v...)
186 | }
187 | 
188 | 
189 | func Fatalln (v ...interface{}) {
190 | 	defaultLogger.Log(PriCrit, v...)
191 | 	os.Exit(1)
192 | }
193 | func Fatalf (format string, v ...interface{}) {
194 | 	defaultLogger.Logf(PriCrit, format, v...)
195 | 	os.Exit(1)
196 | }
197 | 
198 | func Panicln (v ...interface{}) {
199 | 	s := fmt.Sprint(v...)
200 | 	defaultLogger.Log(PriErr, s)
201 | 	panic(s)
202 | }
203 | func Panicf (format string, v ...interface{}) {
204 | 	s := fmt.Sprintf(format, v...)
205 | 	defaultLogger.Log(PriErr, s)
206 | 	panic(s)
207 | }
208 | 
209 | func Println (v ...interface{}) {
210 | 	defaultLogger.Log(PriInfo, v...)
211 | }
212 | func Printf (format string, v ...interface{}) {
213 | 	defaultLogger.Logf(PriInfo, format, v...)
214 | }
215 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-log/log/fields.go:
--------------------------------------------------------------------------------
 1 | package log
 2 | // Copyright 2013, CoreOS, Inc. All rights reserved.
 3 | //
 4 | // Licensed under the Apache License, Version 2.0 (the "License");
 5 | // you may not use this file except in compliance with the License.
 6 | // You may obtain a copy of the License at
 7 | //
 8 | //   http://www.apache.org/licenses/LICENSE-2.0
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software
11 | // distributed under the License is distributed on an "AS IS" BASIS,
12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | // See the License for the specific language governing permissions and
14 | // limitations under the License.
15 | //
16 | // author: David Fisher <ddf1991@gmail.com>
17 | // based on previous package by: Cong Ding <dinggnu@gmail.com>
18 | 
19 | import (
20 | 	"os"
21 | 	"path"
22 | 	"runtime"
23 | 	"strings"
24 | 	"sync/atomic"
25 | 	"time"
26 | )
27 | 
28 | type Fields map[string]interface{}
29 | 
30 | func (logger *Logger) fieldValues() Fields {
31 | 	now := time.Now()
32 | 	fields := Fields{
33 | 		"prefix":     logger.prefix,               // static field available to all sinks
34 | 		"seq":        logger.nextSeq(),            // auto-incrementing sequence number
35 | 		"start_time": logger.created,              // start time of the logger
36 | 		"time":       now.Format(time.StampMilli), // formatted time of log entry
37 | 		"full_time":  now,                         // time of log entry
38 | 		"rtime":      time.Since(logger.created),  // relative time of log entry since started
39 | 		"pid":        os.Getpid(),                 // process id
40 | 		"executable": logger.executable,           // executable filename
41 | 	}
42 | 
43 | 	if logger.verbose {
44 | 		setVerboseFields(fields)
45 | 	}
46 | 	return fields
47 | }
48 | 
49 | func (logger *Logger) nextSeq() uint64 {
50 | 	return atomic.AddUint64(&logger.seq, 1)
51 | }
52 | 
53 | func setVerboseFields(fields Fields) {
54 | 	callers := make([]uintptr, 10)
55 | 	n := runtime.Callers(3, callers) // starts in (*Logger).Log or similar
56 | 	callers = callers[:n]
57 | 
58 | 	for _, pc := range callers {
59 | 		f := runtime.FuncForPC(pc)
60 | 		if !strings.Contains(f.Name(), "logger.(*Logger)") {
61 | 			fields["funcname"] = f.Name()
62 | 			pathname, lineno := f.FileLine(pc)
63 | 			fields["lineno"] = lineno
64 | 			fields["pathname"] = pathname
65 | 			fields["filename"] = path.Base(pathname)
66 | 			return
67 | 		}
68 | 	}
69 | }
70 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-log/log/logger.go:
--------------------------------------------------------------------------------
 1 | package log
 2 | // Copyright 2013, CoreOS, Inc. All rights reserved.
 3 | //
 4 | // Licensed under the Apache License, Version 2.0 (the "License");
 5 | // you may not use this file except in compliance with the License.
 6 | // You may obtain a copy of the License at
 7 | //
 8 | //   http://www.apache.org/licenses/LICENSE-2.0
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software
11 | // distributed under the License is distributed on an "AS IS" BASIS,
12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | // See the License for the specific language governing permissions and
14 | // limitations under the License.
15 | //
16 | // author: David Fisher <ddf1991@gmail.com>
17 | // based on previous package by: Cong Ding <dinggnu@gmail.com>
18 | 
19 | import (
20 | 	"bitbucket.org/kardianos/osext"
21 | 	"os"
22 | 	"path"
23 | 	"time"
24 | )
25 | 
26 | // Logger is user-immutable immutable struct which can log to several outputs
27 | type Logger struct {
28 | 	sinks   []Sink // the sinks this logger will log to
29 | 	verbose bool   // gather expensive logging data?
30 | 	prefix  string // static field available to all log sinks under this logger
31 | 
32 | 	created    time.Time // time when this logger was created
33 | 	seq        uint64    // sequential number of log message, starting at 1
34 | 	executable string    // executable name
35 | }
36 | 
37 | // New creates a new Logger which logs to all the supplied sinks.  The prefix
38 | // argument is passed to all loggers under the field "prefix" with every log
39 | // message.  If verbose is true, more expensive runtime fields will be computed
40 | // and passed to loggers.  These fields are funcname, lineno, pathname, and
41 | // filename.
42 | func New(prefix string, verbose bool, sinks ...Sink) *Logger {
43 | 	return &Logger{
44 | 		sinks:   sinks,
45 | 		verbose: verbose,
46 | 		prefix:  prefix,
47 | 
48 | 		created:    time.Now(),
49 | 		seq:        0,
50 | 		executable: getExecutableName(),
51 | 	}
52 | }
53 | 
54 | func getExecutableName() string {
55 | 	executablePath, err := osext.Executable()
56 | 	if err != nil {
57 | 		return "(UNKNOWN)"
58 | 	} else {
59 | 		return path.Base(executablePath)
60 | 	}
61 | }
62 | 
63 | // NewSimple(sinks...) is equivalent to New("", false, sinks...)
64 | func NewSimple(sinks ...Sink) *Logger {
65 | 	return New("", false, sinks...)
66 | }
67 | 
68 | var defaultLogger *Logger
69 | 
70 | func init() {
71 | 	defaultLogger = NewSimple(CombinedSink(os.Stdout, BasicFormat, BasicFields))
72 | }
73 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-log/log/priority.go:
--------------------------------------------------------------------------------
 1 | package log
 2 | // Copyright 2013, CoreOS, Inc. All rights reserved.
 3 | //
 4 | // Licensed under the Apache License, Version 2.0 (the "License");
 5 | // you may not use this file except in compliance with the License.
 6 | // You may obtain a copy of the License at
 7 | //
 8 | //   http://www.apache.org/licenses/LICENSE-2.0
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software
11 | // distributed under the License is distributed on an "AS IS" BASIS,
12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | // See the License for the specific language governing permissions and
14 | // limitations under the License.
15 | //
16 | // author: David Fisher <ddf1991@gmail.com>
17 | // based on previous package by: Cong Ding <dinggnu@gmail.com>
18 | 
19 | type Priority int
20 | 
21 | const (
22 | 	PriEmerg Priority = iota
23 | 	PriAlert
24 | 	PriCrit
25 | 	PriErr
26 | 	PriWarning
27 | 	PriNotice
28 | 	PriInfo
29 | 	PriDebug
30 | )
31 | 
32 | func (priority Priority) String() string {
33 | 	switch priority {
34 | 	case PriEmerg:
35 | 		return "EMERGENCY"
36 | 	case PriAlert:
37 | 		return "ALERT"
38 | 	case PriCrit:
39 | 		return "CRITICAL"
40 | 	case PriErr:
41 | 		return "ERROR"
42 | 	case PriWarning:
43 | 		return "WARNING"
44 | 	case PriNotice:
45 | 		return "NOTICE"
46 | 	case PriInfo:
47 | 		return "INFO"
48 | 	case PriDebug:
49 | 		return "DEBUG"
50 | 
51 | 	default:
52 | 		return "UNKNOWN"
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-log/log/sinks.go:
--------------------------------------------------------------------------------
  1 | package log
  2 | // Copyright 2013, CoreOS, Inc. All rights reserved.
  3 | //
  4 | // Licensed under the Apache License, Version 2.0 (the "License");
  5 | // you may not use this file except in compliance with the License.
  6 | // You may obtain a copy of the License at
  7 | //
  8 | //   http://www.apache.org/licenses/LICENSE-2.0
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software
 11 | // distributed under the License is distributed on an "AS IS" BASIS,
 12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | // See the License for the specific language governing permissions and
 14 | // limitations under the License.
 15 | //
 16 | // author: David Fisher <ddf1991@gmail.com>
 17 | // based on previous package by: Cong Ding <dinggnu@gmail.com>
 18 | 
 19 | import (
 20 | 	"fmt"
 21 | 	"github.com/coreos/go-systemd/journal"
 22 | 	"io"
 23 | 	"strings"
 24 | 	"sync"
 25 | )
 26 | 
 27 | const AsyncBuffer = 100
 28 | 
 29 | type Sink interface {
 30 | 	Log(Fields)
 31 | }
 32 | 
 33 | type nullSink struct{}
 34 | 
 35 | func (sink *nullSink) Log(fields Fields) {}
 36 | 
 37 | func NullSink() Sink {
 38 | 	return &nullSink{}
 39 | }
 40 | 
 41 | type writerSink struct {
 42 | 	lock   sync.Mutex
 43 | 	out    io.Writer
 44 | 	format string
 45 | 	fields []string
 46 | }
 47 | 
 48 | func (sink *writerSink) Log(fields Fields) {
 49 | 	vals := make([]interface{}, len(sink.fields))
 50 | 	for i, field := range sink.fields {
 51 | 		var ok bool
 52 | 		vals[i], ok = fields[field]
 53 | 		if !ok {
 54 | 			vals[i] = "???"
 55 | 		}
 56 | 	}
 57 | 
 58 | 	sink.lock.Lock()
 59 | 	defer sink.lock.Unlock()
 60 | 	fmt.Fprintf(sink.out, sink.format, vals...)
 61 | }
 62 | 
 63 | func WriterSink(out io.Writer, format string, fields []string) Sink {
 64 | 	return &writerSink{
 65 | 		out:    out,
 66 | 		format: format,
 67 | 		fields: fields,
 68 | 	}
 69 | }
 70 | 
 71 | type journalSink struct{}
 72 | 
 73 | func (sink *journalSink) Log(fields Fields) {
 74 | 	message := fields["message"].(string)
 75 | 	priority := toJournalPriority(fields["priority"].(Priority))
 76 | 	journalFields := make(map[string]string)
 77 | 	for k, v := range fields {
 78 | 		if k == "message" || k == "priority" {
 79 | 			continue
 80 | 		}
 81 | 		journalFields[strings.ToUpper(k)] = fmt.Sprint(v)
 82 | 	}
 83 | 	journal.Send(message, priority, journalFields)
 84 | }
 85 | 
 86 | func toJournalPriority(priority Priority) journal.Priority {
 87 | 	switch priority {
 88 | 	case PriEmerg:
 89 | 		return journal.PriEmerg
 90 | 	case PriAlert:
 91 | 		return journal.PriAlert
 92 | 	case PriCrit:
 93 | 		return journal.PriCrit
 94 | 	case PriErr:
 95 | 		return journal.PriErr
 96 | 	case PriWarning:
 97 | 		return journal.PriWarning
 98 | 	case PriNotice:
 99 | 		return journal.PriNotice
100 | 	case PriInfo:
101 | 		return journal.PriInfo
102 | 	case PriDebug:
103 | 		return journal.PriDebug
104 | 
105 | 	default:
106 | 		return journal.PriErr
107 | 	}
108 | }
109 | 
110 | func JournalSink() Sink {
111 | 	return &journalSink{}
112 | }
113 | 
114 | type combinedSink struct {
115 | 	sinks []Sink
116 | }
117 | 
118 | func (sink *combinedSink) Log(fields Fields) {
119 | 	for _, s := range sink.sinks {
120 | 		s.Log(fields)
121 | 	}
122 | }
123 | 
124 | func CombinedSink(writer io.Writer, format string, fields []string) Sink {
125 | 	sinks := make([]Sink, 0)
126 | 	sinks = append(sinks, WriterSink(writer, format, fields))
127 | 	if journal.Enabled() {
128 | 		sinks = append(sinks, JournalSink())
129 | 	}
130 | 
131 | 	return &combinedSink{
132 | 		sinks: sinks,
133 | 	}
134 | }
135 | 
136 | type priorityFilter struct {
137 | 	priority Priority
138 | 	target   Sink
139 | }
140 | 
141 | func (filter *priorityFilter) Log(fields Fields) {
142 | 	// lower priority values indicate more important messages
143 | 	if fields["priority"].(Priority) <= filter.priority {
144 | 		filter.target.Log(fields)
145 | 	}
146 | }
147 | 
148 | func PriorityFilter(priority Priority, target Sink) Sink {
149 | 	return &priorityFilter{
150 | 		priority: priority,
151 | 		target:   target,
152 | 	}
153 | }
154 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-namespaces/README.md:
--------------------------------------------------------------------------------
 1 | ## go-namespaces
 2 | 
 3 | Golang implementations of Linux Namespaces
 4 | 
 5 | ### nspipe
 6 | 
 7 | nspipe is a simple example application included with go-namespaces.
 8 | It lets you bind a socket into a namespace and connect the other end to some other tcp address.
 9 | 
10 | Outside the namespace in a namespace with routable internet networking:
11 | 
12 | ```sh
13 | nspipe -t $TARGET_PID
14 | ```
15 | 
16 | Inside the namespace with private networking:
17 | 
18 | ```sh
19 | telnet 127.0.0.1 23
20 | ```
21 | 
22 | You can also create a new namespace using iproute2
23 | 
24 | ```sh
25 | sudo ip netns add test
26 | sudo ip netns exec test netstat -ltup
27 | ```
28 | 
29 | ```sh
30 | nspipe -p /var/run/netns/test
31 | sudo ip netns  exec test netstat -ltup
32 | ```
33 | 
34 | ### Libraries
35 | 
36 | - [github.com/coreos/go-namespaces/net](http://godoc.org/github.com/coreos/go-namespaces/net)
37 | - [github.com/coreos/go-namespaces/namespace](http://godoc.org/github.com/coreos/go-namespaces/namespace)
38 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-namespaces/build:
--------------------------------------------------------------------------------
1 | go run third_party.go install github.com/coreos/go-namespaces/nspipe
2 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-namespaces/namespace/linux_x86_64.go:
--------------------------------------------------------------------------------
1 | // +build linux,x86_64
2 | package namespace
3 | 
4 | const (
5 | 	SYS_SETNS = 308
6 | )
7 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-namespaces/namespace/namespace.go:
--------------------------------------------------------------------------------
 1 | // namespace implements low level APIs for moving a process into a given Linux Namespace.
 2 | package namespace
 3 | 
 4 | import (
 5 | 	"errors"
 6 | 	"os"
 7 | 	"path"
 8 | 	"strconv"
 9 | 	"syscall"
10 | )
11 | 
12 | type Namespace struct {
13 | 	Path string
14 | 	Type uintptr
15 | }
16 | 
17 | // Namespaces
18 | const (
19 | 	CLONE_NEWNS   = 0x00020000
20 | 	CLONE_NEWUTS  = 0x04000000
21 | 	CLONE_NEWIPC  = 0x08000000
22 | 	CLONE_NEWNET  = 0x40000000
23 | 	CLONE_NEWUSER = 0x10000000
24 | 	CLONE_NEWPID  = 0x20000000
25 | )
26 | 
27 | var (
28 | 	Types []Namespace
29 | )
30 | 
31 | func init() {
32 | 	Types = []Namespace{
33 | 		Namespace{Path: "ns/user", Type: CLONE_NEWUSER},
34 | 		Namespace{Path: "ns/ipc", Type: CLONE_NEWIPC},
35 | 		Namespace{Path: "ns/uts", Type: CLONE_NEWUTS},
36 | 		Namespace{Path: "ns/net", Type: CLONE_NEWNET},
37 | 		Namespace{Path: "ns/pid", Type: CLONE_NEWPID},
38 | 		Namespace{Path: "ns/mnt", Type: CLONE_NEWNS},
39 | 	}
40 | }
41 | 
42 | // Setns is a wrapper around Syscall for the SYS_SETNS
43 | func Setns(fd uintptr, nstype uintptr) syscall.Errno {
44 | 	// TODO: make this work on non-amd64 architectures
45 | 	_, _, err := syscall.Syscall(SYS_SETNS, uintptr(fd), uintptr(nstype), 0)
46 | 	return err
47 | }
48 | 
49 | // ProcessPath returns the path to a namespace given a target pid and namespace type.
50 | func ProcessPath(pid int, nstype uintptr) (string, error) {
51 | 	var nsPath string
52 | 
53 | 	for _, n := range Types {
54 | 		if n.Type == nstype {
55 | 			nsPath = path.Join("/", "proc", strconv.Itoa(pid), n.Path)
56 | 		}
57 | 	}
58 | 
59 | 	if nsPath == "" {
60 | 		return "", errors.New("Cannot find namespace type")
61 | 	}
62 | 
63 | 	return nsPath, nil
64 | }
65 | 
66 | // OpenProcess opens a file descriptor for a given pid and type and returns
67 | // the open fd. The caller is responsible for closing the fd.
68 | func OpenProcess(pid int, nstype uintptr) (uintptr, error) {
69 | 	nsPath, err := ProcessPath(pid, nstype)
70 | 	if err != nil {
71 | 		return 0, err
72 | 	}
73 | 	return Open(nsPath)
74 | }
75 | 
76 | // Opens the given path and returns the raw file descriptor.
77 | // The returned fd acts as the handle to the namespace.
78 | func Open(nsPath string)  (uintptr, error) {
79 | 	file, err := os.Open(nsPath)
80 | 	if err != nil {
81 | 		return 0, err
82 | 	}
83 | 
84 | 	return file.Fd(), nil
85 | }
86 | 
87 | // Close closes a namespace.
88 | func Close(fd uintptr) error {
89 | 	return syscall.Close(int(fd))
90 | }
91 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-namespaces/net/net.go:
--------------------------------------------------------------------------------
 1 | // net implements a simple interface to the network namespaces.
 2 | package net
 3 | 
 4 | import (
 5 | 	gnet "net"
 6 | 	"os"
 7 | 	"syscall"
 8 | 
 9 | 	"github.com/coreos/go-namespaces/namespace"
10 | )
11 | 
12 | func socketat(fd int, net, laddr string) (gnet.Listener, error) {
13 | 	origNs, _ := namespace.OpenProcess(os.Getpid(), namespace.CLONE_NEWNET)
14 | 	defer syscall.Close(int(origNs))
15 | 	defer namespace.Setns(origNs, namespace.CLONE_NEWNET)
16 | 
17 | 	// Join the container namespace
18 | 	err := namespace.Setns(uintptr(fd), namespace.CLONE_NEWNET)
19 | 	if err != 0 {
20 | 		return nil, err
21 | 	}
22 | 
23 | 	// Create our socket
24 | 	return gnet.Listen(net, laddr)
25 | }
26 | 
27 | // ListenProcessNamespace creates a net.Listener in the namespace of the given pid.
28 | // The arguments are identical to net.Listen.
29 | func ListenProcessNamespace(pid uintptr, net, laddr string) (gnet.Listener, error) {
30 | 	fd, err := namespace.OpenProcess(int(pid), namespace.CLONE_NEWNET)
31 | 	defer namespace.Close(fd)
32 | 	if err != nil {
33 | 		return nil, err
34 | 	}
35 | 
36 | 	return socketat(int(fd), net, laddr)
37 | }
38 | 
39 | // ListenNamespace creates a net.Listener in the namespace of the given namespace path.
40 | // The arguments are identical to net.Listen.
41 | func ListenNamespace(nsPath string, net, laddr string) (gnet.Listener, error) {
42 | 	fd, err := namespace.Open(nsPath)
43 | 	defer namespace.Close(fd)
44 | 	if err != nil {
45 | 		return nil, err
46 | 	}
47 | 
48 | 	return socketat(int(fd), net, laddr)
49 | }
50 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-namespaces/nspipe/nspipe.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"fmt"
 6 | 	"io"
 7 | 	"log"
 8 | 	"net"
 9 | 	"os"
10 | 
11 | 	nameNet "github.com/coreos/go-namespaces/net"
12 | 	"github.com/coreos/go-namespaces/namespace"
13 | )
14 | 
15 | var target *int = flag.Int("t", 0, "target pid")
16 | var path *string = flag.String("p", "", "target path")
17 | var targetAddr *string = flag.String("l", "localhost:23", "local address")
18 | var remoteAddr *string = flag.String("r", "towel.blinkenlights.nl:23", "remote address")
19 | 
20 | func proxyConn(conn *net.Conn) {
21 | 	rConn, err := net.Dial("tcp", *remoteAddr)
22 | 	if err != nil {
23 | 		panic(err)
24 | 	}
25 | 
26 | 	go io.Copy(rConn, *conn)
27 | 	go io.Copy(*conn, rConn)
28 | }
29 | 
30 | func main() {
31 | 	flag.Parse()
32 | 
33 | 	if *target == 0  && *path == "" {
34 | 		fmt.Fprintln(os.Stderr, "error: a target pid or path is required")
35 | 		flag.PrintDefaults()
36 | 		return
37 | 	}
38 | 
39 | 	if *target != 0 {
40 | 		p, err := namespace.ProcessPath(*target, namespace.CLONE_NEWNET)
41 | 		if err != nil {
42 | 			panic(err)
43 | 		}
44 | 		*path = p
45 | 	}
46 | 
47 | 	fmt.Printf("PROXY: targetPath:%d targetAddr:%v remoteAddr:%v\n",
48 | 		*path, *targetAddr, *remoteAddr)
49 | 
50 | 	listener, err := nameNet.ListenNamespace(*path, "tcp", *targetAddr)
51 | 	if err != nil {
52 | 		panic(err)
53 | 	}
54 | 
55 | 	for {
56 | 		// Wait for a connection.
57 | 		conn, err := listener.Accept()
58 | 		if err != nil {
59 | 			log.Fatal(err)
60 | 		}
61 | 		go proxyConn(&conn)
62 | 	}
63 | }
64 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-namespaces/third_party.go:
--------------------------------------------------------------------------------
  1 | // +build ignore
  2 | 
  3 | /*
  4 | Copyright 2013 Brandon Philips
  5 | 
  6 | Licensed under the Apache License, Version 2.0 (the "License");
  7 | you may not use this file except in compliance with the License.
  8 | You may obtain a copy of the License at
  9 | 
 10 |      http://www.apache.org/licenses/LICENSE-2.0
 11 | 
 12 | Unless required by applicable law or agreed to in writing, software
 13 | distributed under the License is distributed on an "AS IS" BASIS,
 14 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | See the License for the specific language governing permissions and
 16 | limitations under the License.
 17 | */
 18 | 
 19 | // This program builds a project and is a copy of path.go. See
 20 | // github.com/philips/path.go
 21 | //
 22 | // $ go run path.go
 23 | //
 24 | // See the README file for more details.
 25 | package main
 26 | 
 27 | import (
 28 | 	"fmt"
 29 | 	"io"
 30 | 	"io/ioutil"
 31 | 	"log"
 32 | 	"os"
 33 | 	"os/exec"
 34 | 	"path"
 35 | 	"path/filepath"
 36 | 	"strings"
 37 | )
 38 | 
 39 | const (
 40 | 	DefaultThirdParty = "third_party"
 41 | )
 42 | 
 43 | // thirdPartyDir creates a string path to the third_party directory based on
 44 | // the current working directory.
 45 | func thirdPartyDir() string {
 46 | 	root, err := os.Getwd()
 47 | 	if err != nil {
 48 | 		log.Fatalf("Failed to get the current working directory: %v", err)
 49 | 	}
 50 | 	return path.Join(root, DefaultThirdParty)
 51 | }
 52 | 
 53 | func srcDir() string {
 54 | 	return path.Join(thirdPartyDir(), "src")
 55 | }
 56 | 
 57 | // binDir creates a string path to the GOBIN directory based on the current
 58 | // working directory.
 59 | func binDir() string {
 60 | 	root, err := os.Getwd()
 61 | 	if err != nil {
 62 | 		log.Fatalf("Failed to get the current working directory: %v", err)
 63 | 	}
 64 | 	return path.Join(root, "bin")
 65 | }
 66 | 
 67 | // runEnv execs a command like a shell script piping everything to the parent's
 68 | // stderr/stdout and uses the given environment.
 69 | func runEnv(env []string, name string, arg ...string) {
 70 | 	cmd := exec.Command(name, arg...)
 71 | 
 72 | 	cmd.Env = env
 73 | 
 74 | 	stdout, err := cmd.StdoutPipe()
 75 | 	if err != nil {
 76 | 		fmt.Fprintf(os.Stderr, err.Error())
 77 | 		os.Exit(1)
 78 | 	}
 79 | 	stderr, err := cmd.StderrPipe()
 80 | 	if err != nil {
 81 | 		fmt.Fprintf(os.Stderr, err.Error())
 82 | 		os.Exit(1)
 83 | 	}
 84 | 	err = cmd.Start()
 85 | 	if err != nil {
 86 | 		fmt.Fprintf(os.Stderr, err.Error())
 87 | 		os.Exit(1)
 88 | 	}
 89 | 	go io.Copy(os.Stdout, stdout)
 90 | 	go io.Copy(os.Stderr, stderr)
 91 | 	cmd.Wait()
 92 | }
 93 | 
 94 | // run calls runEnv with the GOPATH third_party packages.
 95 | func run(name string, arg ...string) {
 96 | 	env := append(os.Environ(),
 97 | 		"GOPATH="+thirdPartyDir(),
 98 | 		"GOBIN="+binDir(),
 99 | 	)
100 | 
101 | 	runEnv(env, name, arg...)
102 | }
103 | 
104 | // setupProject does the initial setup of the third_party src directory
105 | // including setting up the symlink to the cwd from the src directory.
106 | func setupProject(pkg string) {
107 | 	root, err := os.Getwd()
108 | 	if err != nil {
109 | 		log.Fatalf("Failed to get the current working directory: %v", err)
110 | 	}
111 | 
112 | 	src := path.Join(thirdPartyDir(), "src", pkg)
113 | 	srcdir := path.Dir(src)
114 | 
115 | 	os.MkdirAll(srcdir, 0755)
116 | 
117 | 	rel, err := filepath.Rel(srcdir, root)
118 | 	if err != nil {
119 | 		log.Fatalf("creating relative third party path: %v", err)
120 | 	}
121 | 
122 | 	err = os.Symlink(rel, src)
123 | 	if err != nil && os.IsExist(err) == false {
124 | 		log.Fatalf("creating project third party symlink: %v", err)
125 | 	}
126 | }
127 | 
128 | // commit grabs the commit id from hg or git as a string.
129 | func commit(dir string) string {
130 | 	base := path.Base(dir)
131 | 	switch base {
132 | 	case ".git":
133 | 		return commitGit(dir)
134 | 	case ".hg":
135 | 		return commitHg(dir)
136 | 	default:
137 | 		return ""
138 | 	}
139 | }
140 | 
141 | // commitGit returns the current HEAD commit hash for a given git dir.
142 | func commitGit(dir string) string {
143 | 	out, err := exec.Command("git", "--git-dir="+dir, "rev-parse", "HEAD").Output()
144 | 	if err != nil {
145 | 		return ""
146 | 	}
147 | 	return string(out)
148 | }
149 | 
150 | // commitHg returns the current HEAD commit hash for a given git dir.
151 | func commitHg(dir string) string {
152 | 	out, err := exec.Command("hg", "id", "-i", "-R", dir).Output()
153 | 	if err != nil {
154 | 		return ""
155 | 	}
156 | 	return string(out)
157 | }
158 | 
159 | // removeVcs removes a .git or .hg directory from the given root if it exists.
160 | func removeVcs(root string) (bool, string) {
161 | 	for _, v := range []string{".git", ".hg"} {
162 | 		r := path.Join(root, v)
163 | 		info, err := os.Stat(r)
164 | 
165 | 		if err != nil {
166 | 			continue
167 | 		}
168 | 
169 | 		// We didn't find it, next!
170 | 		if info.IsDir() == false {
171 | 			continue
172 | 		}
173 | 
174 | 		// We found it, grab the commit and remove the directory
175 | 		c := commit(r)
176 | 		err = os.RemoveAll(r)
177 | 		if err != nil {
178 | 			log.Fatalf("removeVcs: %v", err)
179 | 		}
180 | 		return true, c
181 | 	}
182 | 
183 | 	return false, ""
184 | }
185 | 
186 | // bump takes care of grabbing a package, getting the package git hash and
187 | // removing all of the version control stuff.
188 | func bump(pkg string) {
189 | 	tpd := thirdPartyDir()
190 | 
191 | 	temp, _ := ioutil.TempDir(tpd, "bump")
192 | 	defer os.RemoveAll(temp)
193 | 
194 | 	env := append(os.Environ(),
195 | 		"GOPATH="+temp,
196 | 	)
197 | 
198 | 	runEnv(env, "go", "get", "-u", "-d", pkg)
199 | 
200 | 	for {
201 | 		root := path.Join(temp, "src", pkg) // the temp installation root
202 | 		home := path.Join(tpd, "src", pkg)  // where the package will end up
203 | 
204 | 		ok, c := removeVcs(root)
205 | 		if ok {
206 | 			// Create the path leading up to the package
207 | 			err := os.MkdirAll(path.Dir(home), 0755)
208 | 			if err != nil {
209 | 				log.Fatalf("bump: %v", err)
210 | 			}
211 | 
212 | 			// Remove anything that might have been there
213 | 			err = os.RemoveAll(home)
214 | 			if err != nil {
215 | 				log.Fatalf("bump: %v", err)
216 | 			}
217 | 
218 | 			// Finally move the package
219 | 			err = os.Rename(root, home)
220 | 			if err != nil {
221 | 				log.Fatalf("bump: %v", err)
222 | 			}
223 | 
224 | 			fmt.Printf("%s %s\n", pkg, strings.TrimSpace(c))
225 | 			break
226 | 		}
227 | 
228 | 		// Pop off and try to find this directory!
229 | 		pkg = path.Dir(pkg)
230 | 		if pkg == "." {
231 | 			return
232 | 		}
233 | 	}
234 | }
235 | 
236 | // validPkg uses go list to decide if the given path is a valid go package.
237 | // This is used by the bumpAll walk to bump all of the existing packages.
238 | func validPkg(pkg string) bool {
239 | 	env := append(os.Environ(),
240 | 		"GOPATH="+thirdPartyDir(),
241 | 	)
242 | 	cmd := exec.Command("go", "list", pkg)
243 | 	cmd.Env = env
244 | 
245 | 	out, err := cmd.Output()
246 | 	if err != nil {
247 | 		return false
248 | 	}
249 | 
250 | 	if pkg == strings.TrimSpace(string(out)) {
251 | 		return true
252 | 	}
253 | 
254 | 	return false
255 | }
256 | 
257 | // bumpWalk walks the third_party directory and bumps all of the packages that it finds.
258 | func bumpWalk(path string, info os.FileInfo, err error) error {
259 | 	if err != nil {
260 | 		return nil
261 | 	}
262 | 
263 | 	// go packages are always directories
264 | 	if info.IsDir() == false {
265 | 		return nil
266 | 	}
267 | 
268 | 	parts := strings.Split(path, srcDir()+"/")
269 | 	if len(parts) == 1 {
270 | 		return nil
271 | 	}
272 | 
273 | 	pkg := parts[1]
274 | 
275 | 	if validPkg(pkg) == false {
276 | 		return nil
277 | 	}
278 | 
279 | 	bump(pkg)
280 | 
281 | 	return nil
282 | }
283 | 
284 | func bumpAll() {
285 | 	err := filepath.Walk(srcDir(), bumpWalk)
286 | 	if err != nil {
287 | 		log.Fatalf(err.Error())
288 | 	}
289 | }
290 | 
291 | func main() {
292 | 	log.SetFlags(0)
293 | 
294 | 	if len(os.Args) <= 1 {
295 | 		log.Fatalf("No commnad")
296 | 	}
297 | 
298 | 	cmd := os.Args[1]
299 | 
300 | 	if cmd == "setup" && len(os.Args) > 2 {
301 | 		setupProject(os.Args[2])
302 | 		return
303 | 	}
304 | 
305 | 	if cmd == "bump" && len(os.Args) > 2 {
306 | 		bump(os.Args[2])
307 | 		return
308 | 	}
309 | 
310 | 	if cmd == "bump-all" && len(os.Args) > 1 {
311 | 		bumpAll()
312 | 		return
313 | 	}
314 | 
315 | 	run("go", os.Args[1:]...)
316 | }
317 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-namespaces/third_party/src/github.com/coreos/go-namespaces:
--------------------------------------------------------------------------------
1 | ../../../..


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/LICENSE:
--------------------------------------------------------------------------------
  1 | Apache License
  2 | Version 2.0, January 2004
  3 | http://www.apache.org/licenses/
  4 | 
  5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 | 1. Definitions.
  8 | 
  9 | "License" shall mean the terms and conditions for use, reproduction, and
 10 | distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 | "Licensor" shall mean the copyright owner or entity authorized by the copyright
 13 | owner that is granting the License.
 14 | 
 15 | "Legal Entity" shall mean the union of the acting entity and all other entities
 16 | that control, are controlled by, or are under common control with that entity.
 17 | For the purposes of this definition, "control" means (i) the power, direct or
 18 | indirect, to cause the direction or management of such entity, whether by
 19 | contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
 20 | outstanding shares, or (iii) beneficial ownership of such entity.
 21 | 
 22 | "You" (or "Your") shall mean an individual or Legal Entity exercising
 23 | permissions granted by this License.
 24 | 
 25 | "Source" form shall mean the preferred form for making modifications, including
 26 | but not limited to software source code, documentation source, and configuration
 27 | files.
 28 | 
 29 | "Object" form shall mean any form resulting from mechanical transformation or
 30 | translation of a Source form, including but not limited to compiled object code,
 31 | generated documentation, and conversions to other media types.
 32 | 
 33 | "Work" shall mean the work of authorship, whether in Source or Object form, made
 34 | available under the License, as indicated by a copyright notice that is included
 35 | in or attached to the work (an example is provided in the Appendix below).
 36 | 
 37 | "Derivative Works" shall mean any work, whether in Source or Object form, that
 38 | is based on (or derived from) the Work and for which the editorial revisions,
 39 | annotations, elaborations, or other modifications represent, as a whole, an
 40 | original work of authorship. For the purposes of this License, Derivative Works
 41 | shall not include works that remain separable from, or merely link (or bind by
 42 | name) to the interfaces of, the Work and Derivative Works thereof.
 43 | 
 44 | "Contribution" shall mean any work of authorship, including the original version
 45 | of the Work and any modifications or additions to that Work or Derivative Works
 46 | thereof, that is intentionally submitted to Licensor for inclusion in the Work
 47 | by the copyright owner or by an individual or Legal Entity authorized to submit
 48 | on behalf of the copyright owner. For the purposes of this definition,
 49 | "submitted" means any form of electronic, verbal, or written communication sent
 50 | to the Licensor or its representatives, including but not limited to
 51 | communication on electronic mailing lists, source code control systems, and
 52 | issue tracking systems that are managed by, or on behalf of, the Licensor for
 53 | the purpose of discussing and improving the Work, but excluding communication
 54 | that is conspicuously marked or otherwise designated in writing by the copyright
 55 | owner as "Not a Contribution."
 56 | 
 57 | "Contributor" shall mean Licensor and any individual or Legal Entity on behalf
 58 | of whom a Contribution has been received by Licensor and subsequently
 59 | incorporated within the Work.
 60 | 
 61 | 2. Grant of Copyright License.
 62 | 
 63 | Subject to the terms and conditions of this License, each Contributor hereby
 64 | grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 65 | irrevocable copyright license to reproduce, prepare Derivative Works of,
 66 | publicly display, publicly perform, sublicense, and distribute the Work and such
 67 | Derivative Works in Source or Object form.
 68 | 
 69 | 3. Grant of Patent License.
 70 | 
 71 | Subject to the terms and conditions of this License, each Contributor hereby
 72 | grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 73 | irrevocable (except as stated in this section) patent license to make, have
 74 | made, use, offer to sell, sell, import, and otherwise transfer the Work, where
 75 | such license applies only to those patent claims licensable by such Contributor
 76 | that are necessarily infringed by their Contribution(s) alone or by combination
 77 | of their Contribution(s) with the Work to which such Contribution(s) was
 78 | submitted. If You institute patent litigation against any entity (including a
 79 | cross-claim or counterclaim in a lawsuit) alleging that the Work or a
 80 | Contribution incorporated within the Work constitutes direct or contributory
 81 | patent infringement, then any patent licenses granted to You under this License
 82 | for that Work shall terminate as of the date such litigation is filed.
 83 | 
 84 | 4. Redistribution.
 85 | 
 86 | You may reproduce and distribute copies of the Work or Derivative Works thereof
 87 | in any medium, with or without modifications, and in Source or Object form,
 88 | provided that You meet the following conditions:
 89 | 
 90 | You must give any other recipients of the Work or Derivative Works a copy of
 91 | this License; and
 92 | You must cause any modified files to carry prominent notices stating that You
 93 | changed the files; and
 94 | You must retain, in the Source form of any Derivative Works that You distribute,
 95 | all copyright, patent, trademark, and attribution notices from the Source form
 96 | of the Work, excluding those notices that do not pertain to any part of the
 97 | Derivative Works; and
 98 | If the Work includes a "NOTICE" text file as part of its distribution, then any
 99 | Derivative Works that You distribute must include a readable copy of the
100 | attribution notices contained within such NOTICE file, excluding those notices
101 | that do not pertain to any part of the Derivative Works, in at least one of the
102 | following places: within a NOTICE text file distributed as part of the
103 | Derivative Works; within the Source form or documentation, if provided along
104 | with the Derivative Works; or, within a display generated by the Derivative
105 | Works, if and wherever such third-party notices normally appear. The contents of
106 | the NOTICE file are for informational purposes only and do not modify the
107 | License. You may add Your own attribution notices within Derivative Works that
108 | You distribute, alongside or as an addendum to the NOTICE text from the Work,
109 | provided that such additional attribution notices cannot be construed as
110 | modifying the License.
111 | You may add Your own copyright statement to Your modifications and may provide
112 | additional or different license terms and conditions for use, reproduction, or
113 | distribution of Your modifications, or for any such Derivative Works as a whole,
114 | provided Your use, reproduction, and distribution of the Work otherwise complies
115 | with the conditions stated in this License.
116 | 
117 | 5. Submission of Contributions.
118 | 
119 | Unless You explicitly state otherwise, any Contribution intentionally submitted
120 | for inclusion in the Work by You to the Licensor shall be under the terms and
121 | conditions of this License, without any additional terms or conditions.
122 | Notwithstanding the above, nothing herein shall supersede or modify the terms of
123 | any separate license agreement you may have executed with Licensor regarding
124 | such Contributions.
125 | 
126 | 6. Trademarks.
127 | 
128 | This License does not grant permission to use the trade names, trademarks,
129 | service marks, or product names of the Licensor, except as required for
130 | reasonable and customary use in describing the origin of the Work and
131 | reproducing the content of the NOTICE file.
132 | 
133 | 7. Disclaimer of Warranty.
134 | 
135 | Unless required by applicable law or agreed to in writing, Licensor provides the
136 | Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
137 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
138 | including, without limitation, any warranties or conditions of TITLE,
139 | NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
140 | solely responsible for determining the appropriateness of using or
141 | redistributing the Work and assume any risks associated with Your exercise of
142 | permissions under this License.
143 | 
144 | 8. Limitation of Liability.
145 | 
146 | In no event and under no legal theory, whether in tort (including negligence),
147 | contract, or otherwise, unless required by applicable law (such as deliberate
148 | and grossly negligent acts) or agreed to in writing, shall any Contributor be
149 | liable to You for damages, including any direct, indirect, special, incidental,
150 | or consequential damages of any character arising as a result of this License or
151 | out of the use or inability to use the Work (including but not limited to
152 | damages for loss of goodwill, work stoppage, computer failure or malfunction, or
153 | any and all other commercial damages or losses), even if such Contributor has
154 | been advised of the possibility of such damages.
155 | 
156 | 9. Accepting Warranty or Additional Liability.
157 | 
158 | While redistributing the Work or Derivative Works thereof, You may choose to
159 | offer, and charge a fee for, acceptance of support, warranty, indemnity, or
160 | other liability obligations and/or rights consistent with this License. However,
161 | in accepting such obligations, You may act only on Your own behalf and on Your
162 | sole responsibility, not on behalf of any other Contributor, and only if You
163 | agree to indemnify, defend, and hold each Contributor harmless for any liability
164 | incurred by, or claims asserted against, such Contributor by reason of your
165 | accepting any such warranty or additional liability.
166 | 
167 | END OF TERMS AND CONDITIONS
168 | 
169 | APPENDIX: How to apply the Apache License to your work
170 | 
171 | To apply the Apache License to your work, attach the following boilerplate
172 | notice, with the fields enclosed by brackets "[]" replaced with your own
173 | identifying information. (Don't include the brackets!) The text should be
174 | enclosed in the appropriate comment syntax for the file format. We also
175 | recommend that a file or class name and description of purpose be included on
176 | the same "printed page" as the copyright notice for easier identification within
177 | third-party archives.
178 | 
179 |    Copyright [yyyy] [name of copyright owner]
180 | 
181 |    Licensed under the Apache License, Version 2.0 (the "License");
182 |    you may not use this file except in compliance with the License.
183 |    You may obtain a copy of the License at
184 | 
185 |      http://www.apache.org/licenses/LICENSE-2.0
186 | 
187 |    Unless required by applicable law or agreed to in writing, software
188 |    distributed under the License is distributed on an "AS IS" BASIS,
189 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
190 |    See the License for the specific language governing permissions and
191 |    limitations under the License.
192 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/README.md:
--------------------------------------------------------------------------------
1 | # go-systemd
2 | 
3 | Go bindings to systemd socket activation, journal and D-BUS APIs.
4 | 
5 | ## Socket Activation
6 | 
7 | See an example in `examples/activation/httpserver.go`. For easy debugging use
8 | `/usr/lib/systemd/systemd-activate`
9 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/activation/files.go:
--------------------------------------------------------------------------------
 1 | // Package activation implements primitives for systemd socket activation.
 2 | package activation
 3 | 
 4 | import (
 5 | 	"os"
 6 | 	"strconv"
 7 | 	"syscall"
 8 | )
 9 | 
10 | // based on: https://gist.github.com/alberts/4640792
11 | const (
12 | 	listenFdsStart = 3
13 | )
14 | 
15 | func Files(unsetEnv bool) []*os.File {
16 | 
17 | 	if unsetEnv {
18 | 		// there is no way to unset env in golang os package for now
19 | 		// https://code.google.com/p/go/issues/detail?id=6423
20 | 		defer os.Setenv("LISTEN_PID", "")
21 | 		defer os.Setenv("LISTEN_FDS", "")
22 | 	}
23 | 
24 | 	pid, err := strconv.Atoi(os.Getenv("LISTEN_PID"))
25 | 	if err != nil || pid != os.Getpid() {
26 | 		return nil
27 | 	}
28 | 	nfds, err := strconv.Atoi(os.Getenv("LISTEN_FDS"))
29 | 	if err != nil || nfds == 0 {
30 | 		return nil
31 | 	}
32 | 	var files []*os.File
33 | 	for fd := listenFdsStart; fd < listenFdsStart+nfds; fd++ {
34 | 		syscall.CloseOnExec(fd)
35 | 		files = append(files, os.NewFile(uintptr(fd), "LISTEN_FD_"+strconv.Itoa(fd)))
36 | 	}
37 | 	return files
38 | }
39 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/activation/files_test.go:
--------------------------------------------------------------------------------
 1 | package activation
 2 | 
 3 | import (
 4 | 	"bytes"
 5 | 	"io"
 6 | 	"os"
 7 | 	"os/exec"
 8 | 	"testing"
 9 | )
10 | 
11 | // correctStringWritten fails the text if the correct string wasn't written
12 | // to the other side of the pipe.
13 | func correctStringWritten(t *testing.T, r *os.File, expected string) bool {
14 | 	bytes := make([]byte, len(expected))
15 | 	io.ReadAtLeast(r, bytes, len(expected))
16 | 
17 | 	if string(bytes) != expected {
18 | 		t.Fatalf("Unexpected string %s", string(bytes))
19 | 	}
20 | 
21 | 	return true
22 | }
23 | 
24 | // TestActivation forks out a copy of activation.go example and reads back two
25 | // strings from the pipes that are passed in.
26 | func TestActivation(t *testing.T) {
27 | 	cmd := exec.Command("go", "run", "../examples/activation/activation.go")
28 | 
29 | 	r1, w1, _ := os.Pipe()
30 | 	r2, w2, _ := os.Pipe()
31 | 	cmd.ExtraFiles = []*os.File{
32 | 		w1,
33 | 		w2,
34 | 	}
35 | 
36 | 	cmd.Env = os.Environ()
37 | 	cmd.Env = append(cmd.Env, "LISTEN_FDS=2", "FIX_LISTEN_PID=1")
38 | 
39 | 	err := cmd.Run()
40 | 	if err != nil {
41 | 		t.Fatalf(err.Error())
42 | 	}
43 | 
44 | 	correctStringWritten(t, r1, "Hello world")
45 | 	correctStringWritten(t, r2, "Goodbye world")
46 | }
47 | 
48 | func TestActivationNoFix(t *testing.T) {
49 | 	cmd := exec.Command("go", "run", "../examples/activation/activation.go")
50 | 	cmd.Env = os.Environ()
51 | 	cmd.Env = append(cmd.Env, "LISTEN_FDS=2")
52 | 
53 | 	out, _ := cmd.CombinedOutput()
54 | 	if bytes.Contains(out, []byte("No files")) == false {
55 | 		t.Fatalf("Child didn't error out as expected")
56 | 	}
57 | }
58 | 
59 | func TestActivationNoFiles(t *testing.T) {
60 | 	cmd := exec.Command("go", "run", "../examples/activation/activation.go")
61 | 	cmd.Env = os.Environ()
62 | 	cmd.Env = append(cmd.Env, "LISTEN_FDS=0", "FIX_LISTEN_PID=1")
63 | 
64 | 	out, _ := cmd.CombinedOutput()
65 | 	if bytes.Contains(out, []byte("No files")) == false {
66 | 		t.Fatalf("Child didn't error out as expected")
67 | 	}
68 | }
69 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/dbus/dbus.go:
--------------------------------------------------------------------------------
  1 | // Integration with the systemd D-Bus API.  See http://www.freedesktop.org/wiki/Software/systemd/dbus/
  2 | package dbus
  3 | 
  4 | import (
  5 | 	"github.com/guelfey/go.dbus"
  6 | 	"sync"
  7 | )
  8 | 
  9 | const signalBuffer = 100
 10 | 
 11 | type Conn struct {
 12 | 	sysconn     *dbus.Conn
 13 | 	sysobj      *dbus.Object
 14 | 	jobListener struct {
 15 | 		jobs map[dbus.ObjectPath]chan string
 16 | 		sync.Mutex
 17 | 	}
 18 | 	subscriber struct {
 19 | 		updateCh chan<- *SubStateUpdate
 20 | 		errCh    chan<- error
 21 | 		sync.Mutex
 22 | 		ignore      map[dbus.ObjectPath]int64
 23 | 		cleanIgnore int64
 24 | 	}
 25 | 	dispatch map[string]func(dbus.Signal)
 26 | }
 27 | 
 28 | func New() (*Conn, error) {
 29 | 	c := new(Conn)
 30 | 
 31 | 	if err := c.initConnection(); err != nil {
 32 | 		return nil, err
 33 | 	}
 34 | 
 35 | 	c.initJobs()
 36 | 	c.initSubscription()
 37 | 	c.initDispatch()
 38 | 	return c, nil
 39 | }
 40 | 
 41 | func (c *Conn) initConnection() error {
 42 | 	var err error
 43 | 	c.sysconn, err = dbus.SystemBusPrivate()
 44 | 	if err != nil {
 45 | 		return err
 46 | 	}
 47 | 
 48 | 	err = c.sysconn.Auth(nil)
 49 | 	if err != nil {
 50 | 		c.sysconn.Close()
 51 | 		return err
 52 | 	}
 53 | 
 54 | 	err = c.sysconn.Hello()
 55 | 	if err != nil {
 56 | 		c.sysconn.Close()
 57 | 		return err
 58 | 	}
 59 | 
 60 | 	c.sysobj = c.sysconn.Object("org.freedesktop.systemd1", dbus.ObjectPath("/org/freedesktop/systemd1"))
 61 | 
 62 | 	c.sysconn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0,
 63 | 		"type='signal',interface='org.freedesktop.systemd1.Manager',member='JobRemoved'")
 64 | 	c.sysconn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0,
 65 | 		"type='signal',interface='org.freedesktop.systemd1.Manager',member='UnitNew'")
 66 | 	c.sysconn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0,
 67 | 		"type='signal',interface='org.freedesktop.DBus.Properties',member='PropertiesChanged'")
 68 | 
 69 | 	err = c.sysobj.Call("org.freedesktop.systemd1.Manager.Subscribe", 0).Store()
 70 | 	if err != nil {
 71 | 		c.sysconn.Close()
 72 | 		return err
 73 | 	}
 74 | 
 75 | 	return nil
 76 | }
 77 | 
 78 | func (c *Conn) initDispatch() {
 79 | 	ch := make(chan *dbus.Signal, signalBuffer)
 80 | 
 81 | 	c.sysconn.Signal(ch)
 82 | 
 83 | 	go func() {
 84 | 		for {
 85 | 			signal := <-ch
 86 | 			switch signal.Name {
 87 | 			case "org.freedesktop.systemd1.Manager.JobRemoved":
 88 | 				c.jobComplete(signal)
 89 | 
 90 | 				unitName := signal.Body[2].(string)
 91 | 				var unitPath dbus.ObjectPath
 92 | 				c.sysobj.Call("GetUnit", 0, unitName).Store(&unitPath)
 93 | 				if unitPath != dbus.ObjectPath("") {
 94 | 					c.sendSubStateUpdate(unitPath)
 95 | 				}
 96 | 			case "org.freedesktop.systemd1.Manager.UnitNew":
 97 | 				c.sendSubStateUpdate(signal.Body[1].(dbus.ObjectPath))
 98 | 			case "org.freedesktop.DBus.Properties.PropertiesChanged":
 99 | 				if signal.Body[0].(string) == "org.freedesktop.systemd1.Unit" {
100 | 					// we only care about SubState updates, which are a Unit property
101 | 					c.sendSubStateUpdate(signal.Path)
102 | 				}
103 | 			}
104 | 		}
105 | 	}()
106 | }
107 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/dbus/methods.go:
--------------------------------------------------------------------------------
  1 | package dbus
  2 | 
  3 | import (
  4 | 	"github.com/guelfey/go.dbus"
  5 | )
  6 | 
  7 | func (c *Conn) initJobs() {
  8 | 	c.jobListener.jobs = make(map[dbus.ObjectPath]chan string)
  9 | }
 10 | 
 11 | func (c *Conn) jobComplete(signal *dbus.Signal) {
 12 | 	var id uint32
 13 | 	var job dbus.ObjectPath
 14 | 	var unit string
 15 | 	var result string
 16 | 	dbus.Store(signal.Body, &id, &job, &unit, &result)
 17 | 	c.jobListener.Lock()
 18 | 	out, ok := c.jobListener.jobs[job]
 19 | 	if ok {
 20 | 		out <- result
 21 | 	}
 22 | 	c.jobListener.Unlock()
 23 | }
 24 | 
 25 | func (c *Conn) startJob(job string, args ...interface{}) (<-chan string, error) {
 26 | 	c.jobListener.Lock()
 27 | 	defer c.jobListener.Unlock()
 28 | 
 29 | 	ch := make(chan string, 1)
 30 | 	var path dbus.ObjectPath
 31 | 	err := c.sysobj.Call(job, 0, args...).Store(&path)
 32 | 	if err != nil {
 33 | 		return nil, err
 34 | 	}
 35 | 	c.jobListener.jobs[path] = ch
 36 | 	return ch, nil
 37 | }
 38 | 
 39 | func (c *Conn) runJob(job string, args ...interface{}) (string, error) {
 40 | 	respCh, err := c.startJob(job, args...)
 41 | 	if err != nil {
 42 | 		return "", err
 43 | 	}
 44 | 	return <-respCh, nil
 45 | }
 46 | 
 47 | // StartUnit enqeues a start job and depending jobs, if any (unless otherwise
 48 | // specified by the mode string).
 49 | //
 50 | // Takes the unit to activate, plus a mode string. The mode needs to be one of
 51 | // replace, fail, isolate, ignore-dependencies, ignore-requirements. If
 52 | // "replace" the call will start the unit and its dependencies, possibly
 53 | // replacing already queued jobs that conflict with this. If "fail" the call
 54 | // will start the unit and its dependencies, but will fail if this would change
 55 | // an already queued job. If "isolate" the call will start the unit in question
 56 | // and terminate all units that aren't dependencies of it. If
 57 | // "ignore-dependencies" it will start a unit but ignore all its dependencies.
 58 | // If "ignore-requirements" it will start a unit but only ignore the
 59 | // requirement dependencies. It is not recommended to make use of the latter
 60 | // two options.
 61 | //
 62 | // Result string: one of done, canceled, timeout, failed, dependency, skipped.
 63 | // done indicates successful execution of a job. canceled indicates that a job
 64 | // has been canceled  before it finished execution. timeout indicates that the
 65 | // job timeout was reached. failed indicates that the job failed. dependency
 66 | // indicates that a job this job has been depending on failed and the job hence
 67 | // has been removed too. skipped indicates that a job was skipped because it
 68 | // didn't apply to the units current state.
 69 | func (c *Conn) StartUnit(name string, mode string) (string, error) {
 70 | 	return c.runJob("StartUnit", name, mode)
 71 | }
 72 | 
 73 | // StopUnit is similar to StartUnit but stops the specified unit rather
 74 | // than starting it.
 75 | func (c *Conn) StopUnit(name string, mode string) (string, error) {
 76 | 	return c.runJob("StopUnit", name, mode)
 77 | }
 78 | 
 79 | // ReloadUnit reloads a unit.  Reloading is done only if the unit is already running and fails otherwise.
 80 | func (c *Conn) ReloadUnit(name string, mode string) (string, error) {
 81 | 	return c.runJob("ReloadUnit", name, mode)
 82 | }
 83 | 
 84 | // RestartUnit restarts a service.  If a service is restarted that isn't
 85 | // running it will be started.
 86 | func (c *Conn) RestartUnit(name string, mode string) (string, error) {
 87 | 	return c.runJob("RestartUnit", name, mode)
 88 | }
 89 | 
 90 | // TryRestartUnit is like RestartUnit, except that a service that isn't running
 91 | // is not affected by the restart.
 92 | func (c *Conn) TryRestartUnit(name string, mode string) (string, error) {
 93 | 	return c.runJob("TryRestartUnit", name, mode)
 94 | }
 95 | 
 96 | // ReloadOrRestart attempts a reload if the unit supports it and use a restart
 97 | // otherwise.
 98 | func (c *Conn) ReloadOrRestartUnit(name string, mode string) (string, error) {
 99 | 	return c.runJob("ReloadOrRestartUnit", name, mode)
100 | }
101 | 
102 | // ReloadOrTryRestart attempts a reload if the unit supports it and use a "Try"
103 | // flavored restart otherwise.
104 | func (c *Conn) ReloadOrTryRestartUnit(name string, mode string) (string, error) {
105 | 	return c.runJob("ReloadOrTryRestartUnit", name, mode)
106 | }
107 | 
108 | // StartTransientUnit() may be used to create and start a transient unit, which
109 | // will be released as soon as it is not running or referenced anymore or the
110 | // system is rebooted. name is the unit name including suffix, and must be
111 | // unique. mode is the same as in StartUnit(), properties contains properties
112 | // of the unit.
113 | func (c *Conn) StartTransientUnit(name string, mode string, properties ...Property) (string, error) {
114 | 	// the dbus interface for this method does not use the last argument and
115 | 	// should simply be given an empty list.  We use a concrete type here
116 | 	// (instead of the more appropriate interface{}) to satisfy the dbus library.
117 | 	return c.runJob("StartTransientUnit", name, mode, properties, make([]string, 0))
118 | }
119 | 
120 | // KillUnit takes the unit name and a UNIX signal number to send.  All of the unit's
121 | // processes are killed.
122 | func (c *Conn) KillUnit(name string, signal int32) {
123 | 	c.sysobj.Call("KillUnit", 0, name, "all", signal).Store()
124 | }
125 | 
126 | // ListUnits returns an array with all currently loaded units. Note that
127 | // units may be known by multiple names at the same time, and hence there might
128 | // be more unit names loaded than actual units behind them.
129 | func (c *Conn) ListUnits() ([]UnitStatus, error) {
130 | 	result := make([][]interface{}, 0)
131 | 	err := c.sysobj.Call("ListUnits", 0).Store(&result)
132 | 	if err != nil {
133 | 		return nil, err
134 | 	}
135 | 
136 | 	resultInterface := make([]interface{}, len(result))
137 | 	for i := range result {
138 | 		resultInterface[i] = result[i]
139 | 	}
140 | 
141 | 	status := make([]UnitStatus, len(result))
142 | 	statusInterface := make([]interface{}, len(status))
143 | 	for i := range status {
144 | 		statusInterface[i] = &status[i]
145 | 	}
146 | 
147 | 	err = dbus.Store(resultInterface, statusInterface...)
148 | 	if err != nil {
149 | 		return nil, err
150 | 	}
151 | 
152 | 	return status, nil
153 | }
154 | 
155 | type UnitStatus struct {
156 | 	Name        string          // The primary unit name as string
157 | 	Description string          // The human readable description string
158 | 	LoadState   string          // The load state (i.e. whether the unit file has been loaded successfully)
159 | 	ActiveState string          // The active state (i.e. whether the unit is currently started or not)
160 | 	SubState    string          // The sub state (a more fine-grained version of the active state that is specific to the unit type, which the active state is not)
161 | 	Followed    string          // A unit that is being followed in its state by this unit, if there is any, otherwise the empty string.
162 | 	Path        dbus.ObjectPath // The unit object path
163 | 	JobId       uint32          // If there is a job queued for the job unit the numeric job id, 0 otherwise
164 | 	JobType     string          // The job type as string
165 | 	JobPath     dbus.ObjectPath // The job object path
166 | }
167 | 
168 | // EnableUnitFiles() may be used to enable one or more units in the system (by
169 | // creating symlinks to them in /etc or /run).
170 | //
171 | // It takes a list of unit files to enable (either just file names or full
172 | // absolute paths if the unit files are residing outside the usual unit
173 | // search paths), and two booleans: the first controls whether the unit shall
174 | // be enabled for runtime only (true, /run), or persistently (false, /etc).
175 | // The second one controls whether symlinks pointing to other units shall
176 | // be replaced if necessary.
177 | //
178 | // This call returns one boolean and an array with the changes made. The
179 | // boolean signals whether the unit files contained any enablement
180 | // information (i.e. an [Install]) section. The changes list consists of
181 | // structures with three strings: the type of the change (one of symlink
182 | // or unlink), the file name of the symlink and the destination of the
183 | // symlink.
184 | func (c *Conn) EnableUnitFiles(files []string, runtime bool, force bool) (bool, []EnableUnitFileChange, error) {
185 | 	var carries_install_info bool
186 | 
187 | 	result := make([][]interface{}, 0)
188 | 	err := c.sysobj.Call("EnableUnitFiles", 0, files, runtime, force).Store(&carries_install_info, &result)
189 | 	if err != nil {
190 | 		return false, nil, err
191 | 	}
192 | 
193 | 	resultInterface := make([]interface{}, len(result))
194 | 	for i := range result {
195 | 		resultInterface[i] = result[i]
196 | 	}
197 | 
198 | 	changes := make([]EnableUnitFileChange, len(result))
199 | 	changesInterface := make([]interface{}, len(changes))
200 | 	for i := range changes {
201 | 		changesInterface[i] = &changes[i]
202 | 	}
203 | 
204 | 	err = dbus.Store(resultInterface, changesInterface...)
205 | 	if err != nil {
206 | 		return false, nil, err
207 | 	}
208 | 
209 | 	return carries_install_info, changes, nil
210 | }
211 | 
212 | type EnableUnitFileChange struct {
213 | 	Type        string // Type of the change (one of symlink or unlink)
214 | 	Filename    string // File name of the symlink
215 | 	Destination string // Destination of the symlink
216 | }
217 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/dbus/properties.go:
--------------------------------------------------------------------------------
  1 | package dbus
  2 | 
  3 | import (
  4 | 	"github.com/guelfey/go.dbus"
  5 | )
  6 | 
  7 | // From the systemd docs:
  8 | //
  9 | // The properties array of StartTransientUnit() may take many of the settings
 10 | // that may also be configured in unit files. Not all parameters are currently
 11 | // accepted though, but we plan to cover more properties with future release.
 12 | // Currently you may set the Description, Slice and all dependency types of
 13 | // units, as well as RemainAfterExit, ExecStart for service units,
 14 | // TimeoutStopUSec and PIDs for scope units, and CPUAccounting, CPUShares,
 15 | // BlockIOAccounting, BlockIOWeight, BlockIOReadBandwidth,
 16 | // BlockIOWriteBandwidth, BlockIODeviceWeight, MemoryAccounting, MemoryLimit,
 17 | // DevicePolicy, DeviceAllow for services/scopes/slices. These fields map
 18 | // directly to their counterparts in unit files and as normal D-Bus object
 19 | // properties. The exception here is the PIDs field of scope units which is
 20 | // used for construction of the scope only and specifies the initial PIDs to
 21 | // add to the scope object.
 22 | 
 23 | type Property struct {
 24 | 	Name  string
 25 | 	Value dbus.Variant
 26 | }
 27 | 
 28 | type execStart struct {
 29 | 	Path             string   // the binary path to execute
 30 | 	Args             []string // an array with all arguments to pass to the executed command, starting with argument 0
 31 | 	UncleanIsFailure bool     // a boolean whether it should be considered a failure if the process exits uncleanly
 32 | }
 33 | 
 34 | // PropExecStart sets the ExecStart service property.  The first argument is a
 35 | // slice with the binary path to execute followed by the arguments to pass to
 36 | // the executed command. See
 37 | // http://www.freedesktop.org/software/systemd/man/systemd.service.html#ExecStart=
 38 | func PropExecStart(command []string, uncleanIsFailure bool) Property {
 39 | 	execStarts := []execStart{
 40 | 		execStart{
 41 | 			Path:             command[0],
 42 | 			Args:             command,
 43 | 			UncleanIsFailure: uncleanIsFailure,
 44 | 		},
 45 | 	}
 46 | 
 47 | 	return Property{
 48 | 		Name:  "ExecStart",
 49 | 		Value: dbus.MakeVariant(execStarts),
 50 | 	}
 51 | }
 52 | 
 53 | // PropRemainAfterExit sets the RemainAfterExit service property. See
 54 | // http://www.freedesktop.org/software/systemd/man/systemd.service.html#RemainAfterExit=
 55 | func PropRemainAfterExit(b bool) Property {
 56 | 	return Property{
 57 | 		Name:  "RemainAfterExit",
 58 | 		Value: dbus.MakeVariant(b),
 59 | 	}
 60 | }
 61 | 
 62 | // PropDescription sets the Description unit property. See
 63 | // http://www.freedesktop.org/software/systemd/man/systemd.unit#Description=
 64 | func PropDescription(desc string) Property {
 65 | 	return Property{
 66 | 		Name:  "Description",
 67 | 		Value: dbus.MakeVariant(desc),
 68 | 	}
 69 | }
 70 | 
 71 | func propDependency(name string, units []string) Property {
 72 | 	return Property{
 73 | 		Name:  name,
 74 | 		Value: dbus.MakeVariant(units),
 75 | 	}
 76 | }
 77 | 
 78 | // PropRequires sets the Requires unit property.  See
 79 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#Requires=
 80 | func PropRequires(units ...string) Property {
 81 | 	return propDependency("Requires", units)
 82 | }
 83 | 
 84 | // PropRequiresOverridable sets the RequiresOverridable unit property.  See
 85 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#RequiresOverridable=
 86 | func PropRequiresOverridable(units ...string) Property {
 87 | 	return propDependency("RequiresOverridable", units)
 88 | }
 89 | 
 90 | // PropRequisite sets the Requisite unit property.  See
 91 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#Requisite=
 92 | func PropRequisite(units ...string) Property {
 93 | 	return propDependency("Requisite", units)
 94 | }
 95 | 
 96 | // PropRequisiteOverridable sets the RequisiteOverridable unit property.  See
 97 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#RequisiteOverridable=
 98 | func PropRequisiteOverridable(units ...string) Property {
 99 | 	return propDependency("RequisiteOverridable", units)
100 | }
101 | 
102 | // PropWants sets the Wants unit property.  See
103 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#Wants=
104 | func PropWants(units ...string) Property {
105 | 	return propDependency("Wants", units)
106 | }
107 | 
108 | // PropBindsTo sets the BindsTo unit property.  See
109 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#BindsTo=
110 | func PropBindsTo(units ...string) Property {
111 | 	return propDependency("BindsTo", units)
112 | }
113 | 
114 | // PropRequiredBy sets the RequiredBy unit property.  See
115 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#RequiredBy=
116 | func PropRequiredBy(units ...string) Property {
117 | 	return propDependency("RequiredBy", units)
118 | }
119 | 
120 | // PropRequiredByOverridable sets the RequiredByOverridable unit property.  See
121 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#RequiredByOverridable=
122 | func PropRequiredByOverridable(units ...string) Property {
123 | 	return propDependency("RequiredByOverridable", units)
124 | }
125 | 
126 | // PropWantedBy sets the WantedBy unit property.  See
127 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#WantedBy=
128 | func PropWantedBy(units ...string) Property {
129 | 	return propDependency("WantedBy", units)
130 | }
131 | 
132 | // PropBoundBy sets the BoundBy unit property.  See
133 | // http://www.freedesktop.org/software/systemd/main/systemd.unit.html#BoundBy=
134 | func PropBoundBy(units ...string) Property {
135 | 	return propDependency("BoundBy", units)
136 | }
137 | 
138 | // PropConflicts sets the Conflicts unit property.  See
139 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#Conflicts=
140 | func PropConflicts(units ...string) Property {
141 | 	return propDependency("Conflicts", units)
142 | }
143 | 
144 | // PropConflictedBy sets the ConflictedBy unit property.  See
145 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#ConflictedBy=
146 | func PropConflictedBy(units ...string) Property {
147 | 	return propDependency("ConflictedBy", units)
148 | }
149 | 
150 | // PropBefore sets the Before unit property.  See
151 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#Before=
152 | func PropBefore(units ...string) Property {
153 | 	return propDependency("Before", units)
154 | }
155 | 
156 | // PropAfter sets the After unit property.  See
157 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#After=
158 | func PropAfter(units ...string) Property {
159 | 	return propDependency("After", units)
160 | }
161 | 
162 | // PropOnFailure sets the OnFailure unit property.  See
163 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#OnFailure=
164 | func PropOnFailure(units ...string) Property {
165 | 	return propDependency("OnFailure", units)
166 | }
167 | 
168 | // PropTriggers sets the Triggers unit property.  See
169 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#Triggers=
170 | func PropTriggers(units ...string) Property {
171 | 	return propDependency("Triggers", units)
172 | }
173 | 
174 | // PropTriggeredBy sets the TriggeredBy unit property.  See
175 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#TriggeredBy=
176 | func PropTriggeredBy(units ...string) Property {
177 | 	return propDependency("TriggeredBy", units)
178 | }
179 | 
180 | // PropPropagatesReloadTo sets the PropagatesReloadTo unit property.  See
181 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#PropagatesReloadTo=
182 | func PropPropagatesReloadTo(units ...string) Property {
183 | 	return propDependency("PropagatesReloadTo", units)
184 | }
185 | 
186 | // PropRequiresMountsFor sets the RequiresMountsFor unit property.  See
187 | // http://www.freedesktop.org/software/systemd/man/systemd.unit.html#RequiresMountsFor=
188 | func PropRequiresMountsFor(units ...string) Property {
189 | 	return propDependency("RequiresMountsFor", units)
190 | }
191 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/dbus/subscription.go:
--------------------------------------------------------------------------------
  1 | package dbus
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"time"
  6 | 
  7 | 	"github.com/guelfey/go.dbus"
  8 | )
  9 | 
 10 | const (
 11 | 	cleanIgnoreInterval = int64(10 * time.Second)
 12 | 	ignoreInterval      = int64(30 * time.Millisecond)
 13 | )
 14 | 
 15 | func (c *Conn) initSubscription() {
 16 | 	c.subscriber.ignore = make(map[dbus.ObjectPath]int64)
 17 | }
 18 | 
 19 | // Returns two unbuffered channels which will receive all changed units every
 20 | // @interval@ seconds.  Deleted units are sent as nil.
 21 | func (c *Conn) SubscribeUnits(interval time.Duration) (<-chan map[string]*UnitStatus, <-chan error) {
 22 | 	return c.SubscribeUnitsCustom(interval, 0, func(u1, u2 *UnitStatus) bool { return *u1 != *u2 })
 23 | }
 24 | 
 25 | // SubscribeUnitsCustom is like SubscribeUnits but lets you specify the buffer
 26 | // size of the channels and the comparison function for detecting changes.
 27 | func (c *Conn) SubscribeUnitsCustom(interval time.Duration, buffer int, isChanged func(*UnitStatus, *UnitStatus) bool) (<-chan map[string]*UnitStatus, <-chan error) {
 28 | 	old := make(map[string]*UnitStatus)
 29 | 	statusChan := make(chan map[string]*UnitStatus, buffer)
 30 | 	errChan := make(chan error, buffer)
 31 | 
 32 | 	go func() {
 33 | 		for {
 34 | 			timerChan := time.After(interval)
 35 | 
 36 | 			units, err := c.ListUnits()
 37 | 			if err == nil {
 38 | 				cur := make(map[string]*UnitStatus)
 39 | 				for i := range units {
 40 | 					cur[units[i].Name] = &units[i]
 41 | 				}
 42 | 
 43 | 				// add all new or changed units
 44 | 				changed := make(map[string]*UnitStatus)
 45 | 				for n, u := range cur {
 46 | 					if oldU, ok := old[n]; !ok || isChanged(oldU, u) {
 47 | 						changed[n] = u
 48 | 					}
 49 | 					delete(old, n)
 50 | 				}
 51 | 
 52 | 				// add all deleted units
 53 | 				for oldN := range old {
 54 | 					changed[oldN] = nil
 55 | 				}
 56 | 
 57 | 				old = cur
 58 | 
 59 | 				statusChan <- changed
 60 | 			} else {
 61 | 				errChan <- err
 62 | 			}
 63 | 
 64 | 			<-timerChan
 65 | 		}
 66 | 	}()
 67 | 
 68 | 	return statusChan, errChan
 69 | }
 70 | 
 71 | type SubStateUpdate struct {
 72 | 	UnitName string
 73 | 	SubState string
 74 | }
 75 | 
 76 | // SetSubStateSubscriber writes to updateCh when any unit's substate changes.
 77 | // Althrough this writes to updateCh on every state change, the reported state
 78 | // may be more recent than the change that generated it (due to an unavoidable
 79 | // race in the systemd dbus interface).  That is, this method provides a good
 80 | // way to keep a current view of all units' states, but is not guaranteed to
 81 | // show every state transition they go through.  Furthermore, state changes
 82 | // will only be written to the channel with non-blocking writes.  If updateCh
 83 | // is full, it attempts to write an error to errCh; if errCh is full, the error
 84 | // passes silently.
 85 | func (c *Conn) SetSubStateSubscriber(updateCh chan<- *SubStateUpdate, errCh chan<- error) {
 86 | 	c.subscriber.Lock()
 87 | 	defer c.subscriber.Unlock()
 88 | 	c.subscriber.updateCh = updateCh
 89 | 	c.subscriber.errCh = errCh
 90 | }
 91 | 
 92 | func (c *Conn) sendSubStateUpdate(path dbus.ObjectPath) {
 93 | 	c.subscriber.Lock()
 94 | 	defer c.subscriber.Unlock()
 95 | 	if c.subscriber.updateCh == nil {
 96 | 		return
 97 | 	}
 98 | 
 99 | 	if c.shouldIgnore(path) {
100 | 		return
101 | 	}
102 | 
103 | 	info, err := c.GetUnitInfo(path)
104 | 	if err != nil {
105 | 		select {
106 | 		case c.subscriber.errCh <- err:
107 | 		default:
108 | 		}
109 | 	}
110 | 
111 | 	name := info["Id"].Value().(string)
112 | 	substate := info["SubState"].Value().(string)
113 | 
114 | 	update := &SubStateUpdate{name, substate}
115 | 	select {
116 | 	case c.subscriber.updateCh <- update:
117 | 	default:
118 | 		select {
119 | 		case c.subscriber.errCh <- errors.New("update channel full!"):
120 | 		default:
121 | 		}
122 | 	}
123 | 
124 | 	c.updateIgnore(path, info)
125 | }
126 | 
127 | func (c *Conn) GetUnitInfo(path dbus.ObjectPath) (map[string]dbus.Variant, error) {
128 | 	var err error
129 | 	var props map[string]dbus.Variant
130 | 	obj := c.sysconn.Object("org.freedesktop.systemd1", path)
131 | 	err = obj.Call("GetAll", 0, "org.freedesktop.systemd1.Unit").Store(&props)
132 | 	if err != nil {
133 | 		return nil, err
134 | 	}
135 | 	return props, nil
136 | }
137 | 
138 | // The ignore functions work around a wart in the systemd dbus interface.
139 | // Requesting the properties of an unloaded unit will cause systemd to send a
140 | // pair of UnitNew/UnitRemoved signals.  Because we need to get a unit's
141 | // properties on UnitNew (as that's the only indication of a new unit coming up
142 | // for the first time), we would enter an infinite loop if we did not attempt
143 | // to detect and ignore these spurious signals.  The signal themselves are
144 | // indistinguishable from relevant ones, so we (somewhat hackishly) ignore an
145 | // unloaded unit's signals for a short time after requesting its properties.
146 | // This means that we will miss e.g. a transient unit being restarted
147 | // *immediately* upon failure and also a transient unit being started
148 | // immediately after requesting its status (with systemctl status, for example,
149 | // because this causes a UnitNew signal to be sent which then causes us to fetch
150 | // the properties).
151 | 
152 | func (c *Conn) shouldIgnore(path dbus.ObjectPath) bool {
153 | 	t, ok := c.subscriber.ignore[path]
154 | 	return ok && t >= time.Now().UnixNano()
155 | }
156 | 
157 | func (c *Conn) updateIgnore(path dbus.ObjectPath, info map[string]dbus.Variant) {
158 | 	c.cleanIgnore()
159 | 
160 | 	// unit is unloaded - it will trigger bad systemd dbus behavior
161 | 	if info["LoadState"].Value().(string) == "not-found" {
162 | 		c.subscriber.ignore[path] = time.Now().UnixNano() + ignoreInterval
163 | 	}
164 | }
165 | 
166 | // without this, ignore would grow unboundedly over time
167 | func (c *Conn) cleanIgnore() {
168 | 	now := time.Now().UnixNano()
169 | 	if c.subscriber.cleanIgnore < now {
170 | 		c.subscriber.cleanIgnore = now + cleanIgnoreInterval
171 | 
172 | 		for p, t := range c.subscriber.ignore {
173 | 			if t < now {
174 | 				delete(c.subscriber.ignore, p)
175 | 			}
176 | 		}
177 | 	}
178 | }
179 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/examples/activation/activation.go:
--------------------------------------------------------------------------------
 1 | // Activation example used by the activation unit tests.
 2 | package main
 3 | 
 4 | import (
 5 | 	"fmt"
 6 | 	"os"
 7 | 
 8 | 	"github.com/coreos/go-systemd/activation"
 9 | )
10 | 
11 | func fixListenPid() {
12 | 	if os.Getenv("FIX_LISTEN_PID") != "" {
13 | 		// HACK: real systemd would set LISTEN_PID before exec'ing but
14 | 		// this is too difficult in golang for the purpose of a test.
15 | 		// Do not do this in real code.
16 | 		os.Setenv("LISTEN_PID", fmt.Sprintf("%d", os.Getpid()))
17 | 	}
18 | }
19 | 
20 | func main() {
21 | 	fixListenPid()
22 | 
23 | 	files := activation.Files(false)
24 | 
25 | 	if len(files) == 0 {
26 | 		panic("No files")
27 | 	}
28 | 
29 | 	if os.Getenv("LISTEN_PID") == "" || os.Getenv("LISTEN_FDS") == "" {
30 | 		panic("Should not unset envs")
31 | 	}
32 | 
33 | 	files = activation.Files(true)
34 | 
35 | 	if os.Getenv("LISTEN_PID") != "" || os.Getenv("LISTEN_FDS") != "" {
36 | 		panic("Can not unset envs")
37 | 	}
38 | 
39 | 	// Write out the expected strings to the two pipes
40 | 	files[0].Write([]byte("Hello world"))
41 | 	files[1].Write([]byte("Goodbye world"))
42 | 
43 | 	return
44 | }
45 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/examples/activation/httpserver/README.md:
--------------------------------------------------------------------------------
1 | Example of using socket activation with systemd to serve a simple HTTP server on http://127.0.0.1:8076
2 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/examples/activation/httpserver/hello.service:
--------------------------------------------------------------------------------
 1 | [Unit]
 2 | Description=Hello World HTTP
 3 | Requires=network.target
 4 | After=multi-user.target
 5 | 
 6 | [Service]
 7 | Type=simple
 8 | ExecStart=/usr/local/bin/httpserver
 9 | 
10 | [Install]
11 | WantedBy=multi-user.target
12 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/examples/activation/httpserver/hello.socket:
--------------------------------------------------------------------------------
1 | [Socket]
2 | ListenStream=127.0.0.1:8076
3 | 
4 | [Install]
5 | WantedBy=sockets.target
6 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/examples/activation/httpserver/httpserver.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"io"
 5 | 	"net"
 6 | 	"net/http"
 7 | 
 8 | 	"github.com/coreos/go-systemd/activation"
 9 | )
10 | 
11 | func HelloServer(w http.ResponseWriter, req *http.Request) {
12 | 	io.WriteString(w, "hello socket activated world!\n")
13 | }
14 | 
15 | func main() {
16 | 	files := activation.Files(true)
17 | 
18 | 	if len(files) != 1 {
19 | 		panic("Unexpected number of socket activation fds")
20 | 	}
21 | 
22 | 	l, err := net.FileListener(files[0])
23 | 	if err != nil {
24 | 		panic(err)
25 | 	}
26 | 
27 | 	http.HandleFunc("/", HelloServer)
28 | 	http.Serve(l, nil)
29 | }
30 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/journal/send.go:
--------------------------------------------------------------------------------
  1 | // Package journal provides write bindings to the systemd journal
  2 | package journal
  3 | 
  4 | import (
  5 | 	"bytes"
  6 | 	"encoding/binary"
  7 | 	"errors"
  8 | 	"fmt"
  9 | 	"io"
 10 | 	"io/ioutil"
 11 | 	"net"
 12 | 	"os"
 13 | 	"strconv"
 14 | 	"strings"
 15 | 	"syscall"
 16 | )
 17 | 
 18 | // Priority of a journal message
 19 | type Priority int
 20 | 
 21 | const (
 22 | 	PriEmerg Priority = iota
 23 | 	PriAlert
 24 | 	PriCrit
 25 | 	PriErr
 26 | 	PriWarning
 27 | 	PriNotice
 28 | 	PriInfo
 29 | 	PriDebug
 30 | )
 31 | 
 32 | var conn net.Conn
 33 | 
 34 | func init() {
 35 | 	var err error
 36 | 	conn, err = net.Dial("unixgram", "/run/systemd/journal/socket")
 37 | 	if err != nil {
 38 | 		conn = nil
 39 | 	}
 40 | }
 41 | 
 42 | // Enabled returns true iff the systemd journal is available for logging
 43 | func Enabled() bool {
 44 | 	return conn != nil
 45 | }
 46 | 
 47 | // Send a message to the systemd journal. vars is a map of journald fields to
 48 | // values.  Fields must be composed of uppercase letters, numbers, and
 49 | // underscores, but must not start with an underscore. Within these
 50 | // restrictions, any arbitrary field name may be used.  Some names have special
 51 | // significance: see the journalctl documentation
 52 | // (http://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html)
 53 | // for more details.  vars may be nil.
 54 | func Send(message string, priority Priority, vars map[string]string) error {
 55 | 	if conn == nil {
 56 | 		return journalError("could not connect to journald socket")
 57 | 	}
 58 | 
 59 | 	data := new(bytes.Buffer)
 60 | 	appendVariable(data, "PRIORITY", strconv.Itoa(int(priority)))
 61 | 	appendVariable(data, "MESSAGE", message)
 62 | 	for k, v := range vars {
 63 | 		appendVariable(data, k, v)
 64 | 	}
 65 | 
 66 | 	_, err := io.Copy(conn, data)
 67 | 	if err != nil && isSocketSpaceError(err) {
 68 | 		file, err := tempFd()
 69 | 		if err != nil {
 70 | 			return journalError(err.Error())
 71 | 		}
 72 | 		_, err = io.Copy(file, data)
 73 | 		if err != nil {
 74 | 			return journalError(err.Error())
 75 | 		}
 76 | 
 77 | 		rights := syscall.UnixRights(int(file.Fd()))
 78 | 
 79 | 		/* this connection should always be a UnixConn, but better safe than sorry */
 80 | 		unixConn, ok := conn.(*net.UnixConn)
 81 | 		if !ok {
 82 | 			return journalError("can't send file through non-Unix connection")
 83 | 		}
 84 | 		unixConn.WriteMsgUnix([]byte{}, rights, nil)
 85 | 	} else if err != nil {
 86 | 		return journalError(err.Error())
 87 | 	}
 88 | 	return nil
 89 | }
 90 | 
 91 | func appendVariable(w io.Writer, name, value string) {
 92 | 	if !validVarName(name) {
 93 | 		journalError("variable name contains invalid character, ignoring")
 94 | 	}
 95 | 	if strings.ContainsRune(value, '\n') {
 96 | 		/* When the value contains a newline, we write:
 97 | 		 * - the variable name, followed by a newline
 98 | 		 * - the size (in 64bit little endian format)
 99 | 		 * - the data, followed by a newline
100 | 		 */
101 | 		fmt.Fprintln(w, name)
102 | 		binary.Write(w, binary.LittleEndian, uint64(len(value)))
103 | 		fmt.Fprintln(w, value)
104 | 	} else {
105 | 		/* just write the variable and value all on one line */
106 | 		fmt.Fprintln(w, "%s=%s", name, value)
107 | 	}
108 | }
109 | 
110 | func validVarName(name string) bool {
111 | 	/* The variable name must be in uppercase and consist only of characters,
112 | 	 * numbers and underscores, and may not begin with an underscore. (from the docs)
113 | 	 */
114 | 
115 | 	valid := name[0] != '_'
116 | 	for _, c := range name {
117 | 		valid = valid && ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '_'
118 | 	}
119 | 	return valid
120 | }
121 | 
122 | func isSocketSpaceError(err error) bool {
123 | 	opErr, ok := err.(*net.OpError)
124 | 	if !ok {
125 | 		return false
126 | 	}
127 | 
128 | 	sysErr, ok := opErr.Err.(syscall.Errno)
129 | 	if !ok {
130 | 		return false
131 | 	}
132 | 
133 | 	return sysErr == syscall.EMSGSIZE || sysErr == syscall.ENOBUFS
134 | }
135 | 
136 | func tempFd() (*os.File, error) {
137 | 	file, err := ioutil.TempFile("/dev/shm/", "journal.XXXXX")
138 | 	if err != nil {
139 | 		return nil, err
140 | 	}
141 | 	syscall.Unlink(file.Name())
142 | 	if err != nil {
143 | 		return nil, err
144 | 	}
145 | 	return file, nil
146 | }
147 | 
148 | func journalError(s string) error {
149 | 	s = "journal error: " + s
150 | 	fmt.Fprintln(os.Stderr, s)
151 | 	return errors.New(s)
152 | }
153 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/go-systemd/test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh -e
 2 | 
 3 | PKG="github.com/coreos/go-systemd"
 4 | 
 5 | rm -R src
 6 | mkdir -p src/$(dirname $PKG)
 7 | ln -s ../../../ src/$PKG
 8 | 
 9 | go test -v ${PKG}/activation
10 | 


--------------------------------------------------------------------------------
/third_party/src/github.com/coreos/nsproxy:
--------------------------------------------------------------------------------
1 | ../../../..


--------------------------------------------------------------------------------
/util.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"strings"
 5 | )
 6 | 
 7 | // trimsplit slices s into all substrings separated by sep and returns a
 8 | // slice of the substrings between the separator with all leading and trailing
 9 | // white space removed, as defined by Unicode.
10 | func trimsplit(s, sep string) []string {
11 | 	raw := strings.Split(s, ",")
12 | 	trimmed := make([]string, 0)
13 | 	for _, r := range raw {
14 | 		trimmed = append(trimmed, strings.TrimSpace(r))
15 | 	}
16 | 	return trimmed
17 | }
18 | 


--------------------------------------------------------------------------------