mirror of https://github.com/docker/docs.git
Cleanup and fix deps
Signed-off-by: Olivier Gambier <olivier@docker.com>
This commit is contained in:
Olivier Gambier
parent
04cfa58445
commit
b3e83da3e6
|
|
@ -1,6 +1,58 @@
|
||||||
{
|
{
|
||||||
"ImportPath": "github.com/docker/machine",
|
"ImportPath": "github.com/docker/machine",
|
||||||
"GoVersion": "go1.5",
|
"GoVersion": "go1.5",
|
||||||
|
"Packages": [
|
||||||
|
"github.com/docker/machine",
|
||||||
|
"github.com/docker/machine/cli",
|
||||||
|
"github.com/docker/machine/cmd",
|
||||||
|
"github.com/docker/machine/commands",
|
||||||
|
"github.com/docker/machine/commands/mcndirs",
|
||||||
|
"github.com/docker/machine/drivers/amazonec2",
|
||||||
|
"github.com/docker/machine/drivers/amazonec2/amz",
|
||||||
|
"github.com/docker/machine/drivers/azure",
|
||||||
|
"github.com/docker/machine/drivers/digitalocean",
|
||||||
|
"github.com/docker/machine/drivers/errdriver",
|
||||||
|
"github.com/docker/machine/drivers/exoscale",
|
||||||
|
"github.com/docker/machine/drivers/fakedriver",
|
||||||
|
"github.com/docker/machine/drivers/generic",
|
||||||
|
"github.com/docker/machine/drivers/google",
|
||||||
|
"github.com/docker/machine/drivers/hyperv",
|
||||||
|
"github.com/docker/machine/drivers/none",
|
||||||
|
"github.com/docker/machine/drivers/openstack",
|
||||||
|
"github.com/docker/machine/drivers/rackspace",
|
||||||
|
"github.com/docker/machine/drivers/softlayer",
|
||||||
|
"github.com/docker/machine/drivers/virtualbox",
|
||||||
|
"github.com/docker/machine/drivers/vmwarefusion",
|
||||||
|
"github.com/docker/machine/drivers/vmwarevcloudair",
|
||||||
|
"github.com/docker/machine/drivers/vmwarevsphere",
|
||||||
|
"github.com/docker/machine/drivers/vmwarevsphere/errors",
|
||||||
|
"github.com/docker/machine/libmachine",
|
||||||
|
"github.com/docker/machine/libmachine/auth",
|
||||||
|
"github.com/docker/machine/libmachine/cert",
|
||||||
|
"github.com/docker/machine/libmachine/drivers",
|
||||||
|
"github.com/docker/machine/libmachine/drivers/plugin",
|
||||||
|
"github.com/docker/machine/libmachine/drivers/plugin/localbinary",
|
||||||
|
"github.com/docker/machine/libmachine/drivers/rpc",
|
||||||
|
"github.com/docker/machine/libmachine/engine",
|
||||||
|
"github.com/docker/machine/libmachine/examples",
|
||||||
|
"github.com/docker/machine/libmachine/host",
|
||||||
|
"github.com/docker/machine/libmachine/hosttest",
|
||||||
|
"github.com/docker/machine/libmachine/log",
|
||||||
|
"github.com/docker/machine/libmachine/mcnerror",
|
||||||
|
"github.com/docker/machine/libmachine/mcnflag",
|
||||||
|
"github.com/docker/machine/libmachine/mcnutils",
|
||||||
|
"github.com/docker/machine/libmachine/persist",
|
||||||
|
"github.com/docker/machine/libmachine/persisttest",
|
||||||
|
"github.com/docker/machine/libmachine/provider",
|
||||||
|
"github.com/docker/machine/libmachine/provision",
|
||||||
|
"github.com/docker/machine/libmachine/provision/pkgaction",
|
||||||
|
"github.com/docker/machine/libmachine/provision/serviceaction",
|
||||||
|
"github.com/docker/machine/libmachine/ssh",
|
||||||
|
"github.com/docker/machine/libmachine/state",
|
||||||
|
"github.com/docker/machine/libmachine/swarm",
|
||||||
|
"github.com/docker/machine/libmachine/version",
|
||||||
|
"github.com/docker/machine/version"
|
||||||
|
],
|
||||||
"Deps": [
|
"Deps": [
|
||||||
{
|
{
|
||||||
"ImportPath": "code.google.com/p/goauth2/oauth",
|
"ImportPath": "code.google.com/p/goauth2/oauth",
|
||||||
|
|
@ -16,95 +68,16 @@
|
||||||
"ImportPath": "github.com/cenkalti/backoff",
|
"ImportPath": "github.com/cenkalti/backoff",
|
||||||
"Rev": "9831e1e25c874e0a0601b6dc43641071414eec7a"
|
"Rev": "9831e1e25c874e0a0601b6dc43641071414eec7a"
|
||||||
},
|
},
|
||||||
{
|
|
||||||
"ImportPath": "github.com/codegangsta/cli",
|
|
||||||
"Comment": "1.2.0-64-ge1712f3",
|
|
||||||
"Rev": "e1712f381785e32046927f64a7c86fe569203196"
|
|
||||||
},
|
|
||||||
{
|
{
|
||||||
"ImportPath": "github.com/digitalocean/godo",
|
"ImportPath": "github.com/digitalocean/godo",
|
||||||
"Comment": "v0.5.0",
|
"Comment": "v0.5.0",
|
||||||
"Rev": "5478aae80694de1d2d0e02c386bbedd201266234"
|
"Rev": "5478aae80694de1d2d0e02c386bbedd201266234"
|
||||||
},
|
},
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/dockerversion",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/engine",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/archive",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/fileutils",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/ioutils",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/mflag",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/parsers",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/pools",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/promise",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/system",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
{
|
||||||
"ImportPath": "github.com/docker/docker/pkg/term",
|
"ImportPath": "github.com/docker/docker/pkg/term",
|
||||||
"Comment": "v1.5.0",
|
"Comment": "v1.5.0",
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
||||||
},
|
},
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/timeutils",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/units",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/pkg/version",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar",
|
|
||||||
"Comment": "v1.5.0",
|
|
||||||
"Rev": "a8a31eff10544860d2188dddabdee4d727545796"
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"ImportPath": "github.com/docker/libtrust",
|
|
||||||
"Rev": "c54fbb67c1f1e68d7d6f8d2ad7c9360404616a41"
|
|
||||||
},
|
|
||||||
{
|
{
|
||||||
"ImportPath": "github.com/google/go-querystring/query",
|
"ImportPath": "github.com/google/go-querystring/query",
|
||||||
"Rev": "30f7a39f4a218feb5325f3aebc60c32a572a8274"
|
"Rev": "30f7a39f4a218feb5325f3aebc60c32a572a8274"
|
||||||
|
|
@ -113,9 +86,13 @@
|
||||||
"ImportPath": "github.com/mitchellh/mapstructure",
|
"ImportPath": "github.com/mitchellh/mapstructure",
|
||||||
"Rev": "740c764bc6149d3f1806231418adb9f52c11bcbf"
|
"Rev": "740c764bc6149d3f1806231418adb9f52c11bcbf"
|
||||||
},
|
},
|
||||||
|
{
|
||||||
|
"ImportPath": "github.com/pyr/egoscale/src/egoscale",
|
||||||
|
"Rev": "bbaa67324aeeacc90430c1fe0a9c620d3929512e"
|
||||||
|
},
|
||||||
{
|
{
|
||||||
"ImportPath": "github.com/rackspace/gophercloud",
|
"ImportPath": "github.com/rackspace/gophercloud",
|
||||||
"Comment": "v1.0.0-558-ce0f487",
|
"Comment": "v1.0.0-558-gce0f487",
|
||||||
"Rev": "ce0f487f6747ab43c4e4404722df25349385bebd"
|
"Rev": "ce0f487f6747ab43c4e4404722df25349385bebd"
|
||||||
},
|
},
|
||||||
{
|
{
|
||||||
|
|
@ -130,10 +107,6 @@
|
||||||
"ImportPath": "github.com/stretchr/testify/assert",
|
"ImportPath": "github.com/stretchr/testify/assert",
|
||||||
"Rev": "e4ec8152c15fc46bd5056ce65997a07c7d415325"
|
"Rev": "e4ec8152c15fc46bd5056ce65997a07c7d415325"
|
||||||
},
|
},
|
||||||
{
|
|
||||||
"ImportPath": "github.com/pyr/egoscale/src/egoscale",
|
|
||||||
"Rev": "bbaa67324aeeacc90430c1fe0a9c620d3929512e"
|
|
||||||
},
|
|
||||||
{
|
{
|
||||||
"ImportPath": "github.com/tent/http-link-go",
|
"ImportPath": "github.com/tent/http-link-go",
|
||||||
"Rev": "ac974c61c2f990f4115b119354b5e0b47550e888"
|
"Rev": "ac974c61c2f990f4115b119354b5e0b47550e888"
|
||||||
|
|
@ -151,6 +124,10 @@
|
||||||
"ImportPath": "golang.org/x/net/context",
|
"ImportPath": "golang.org/x/net/context",
|
||||||
"Rev": "d9558e5c97f85372afee28cf2b6059d7d3818919"
|
"Rev": "d9558e5c97f85372afee28cf2b6059d7d3818919"
|
||||||
},
|
},
|
||||||
|
{
|
||||||
|
"ImportPath": "golang.org/x/oauth2",
|
||||||
|
"Rev": "038cb4adce85ed41e285c2e7cc6221a92bfa44aa"
|
||||||
|
},
|
||||||
{
|
{
|
||||||
"ImportPath": "google.golang.org/api/compute/v1",
|
"ImportPath": "google.golang.org/api/compute/v1",
|
||||||
"Rev": "a09229c13c2f13bbdedf7b31b506cad4c83ef3bf"
|
"Rev": "a09229c13c2f13bbdedf7b31b506cad4c83ef3bf"
|
||||||
|
|
@ -160,11 +137,11 @@
|
||||||
"Rev": "a09229c13c2f13bbdedf7b31b506cad4c83ef3bf"
|
"Rev": "a09229c13c2f13bbdedf7b31b506cad4c83ef3bf"
|
||||||
},
|
},
|
||||||
{
|
{
|
||||||
"ImportPath": "golang.org/x/oauth2",
|
"ImportPath": "google.golang.org/cloud/compute/metadata",
|
||||||
"Rev": "038cb4adce85ed41e285c2e7cc6221a92bfa44aa"
|
"Rev": "2400193c85c3561d13880d34e0e10c4315bb02af"
|
||||||
},
|
},
|
||||||
{
|
{
|
||||||
"ImportPath": "google.golang.org/cloud/compute",
|
"ImportPath": "google.golang.org/cloud/internal",
|
||||||
"Rev": "2400193c85c3561d13880d34e0e10c4315bb02af"
|
"Rev": "2400193c85c3561d13880d34e0e10c4315bb02af"
|
||||||
}
|
}
|
||||||
]
|
]
|
||||||
|
|
|
||||||
|
|
@ -1,2 +0,0 @@
|
||||||
/pkg
|
|
||||||
/bin
|
|
||||||
|
|
@ -1,91 +0,0 @@
|
||||||
#!/usr/bin/perl
|
|
||||||
# Copyright 2011 The Go Authors. All rights reserved.
|
|
||||||
# Use of this source code is governed by a BSD-style
|
|
||||||
# license that can be found in the LICENSE file.
|
|
||||||
#
|
|
||||||
# Test script run as a child process under cgi_test.go
|
|
||||||
|
|
||||||
use strict;
|
|
||||||
use Cwd;
|
|
||||||
|
|
||||||
binmode STDOUT;
|
|
||||||
|
|
||||||
my $q = MiniCGI->new;
|
|
||||||
my $params = $q->Vars;
|
|
||||||
|
|
||||||
if ($params->{"loc"}) {
|
|
||||||
print "Location: $params->{loc}\r\n\r\n";
|
|
||||||
exit(0);
|
|
||||||
}
|
|
||||||
|
|
||||||
print "Content-Type: text/html\r\n";
|
|
||||||
print "X-CGI-Pid: $$\r\n";
|
|
||||||
print "X-Test-Header: X-Test-Value\r\n";
|
|
||||||
print "\r\n";
|
|
||||||
|
|
||||||
if ($params->{"bigresponse"}) {
|
|
||||||
# 17 MB, for OS X: golang.org/issue/4958
|
|
||||||
for (1..(17 * 1024)) {
|
|
||||||
print "A" x 1024, "\r\n";
|
|
||||||
}
|
|
||||||
exit 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
print "test=Hello CGI\r\n";
|
|
||||||
|
|
||||||
foreach my $k (sort keys %$params) {
|
|
||||||
print "param-$k=$params->{$k}\r\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
foreach my $k (sort keys %ENV) {
|
|
||||||
my $clean_env = $ENV{$k};
|
|
||||||
$clean_env =~ s/[\n\r]//g;
|
|
||||||
print "env-$k=$clean_env\r\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
# NOTE: msys perl returns /c/go/src/... not C:\go\....
|
|
||||||
my $dir = getcwd();
|
|
||||||
if ($^O eq 'MSWin32' || $^O eq 'msys') {
|
|
||||||
if ($dir =~ /^.:/) {
|
|
||||||
$dir =~ s!/!\\!g;
|
|
||||||
} else {
|
|
||||||
my $cmd = $ENV{'COMSPEC'} || 'c:\\windows\\system32\\cmd.exe';
|
|
||||||
$cmd =~ s!\\!/!g;
|
|
||||||
$dir = `$cmd /c cd`;
|
|
||||||
chomp $dir;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
print "cwd=$dir\r\n";
|
|
||||||
|
|
||||||
# A minimal version of CGI.pm, for people without the perl-modules
|
|
||||||
# package installed. (CGI.pm used to be part of the Perl core, but
|
|
||||||
# some distros now bundle perl-base and perl-modules separately...)
|
|
||||||
package MiniCGI;
|
|
||||||
|
|
||||||
sub new {
|
|
||||||
my $class = shift;
|
|
||||||
return bless {}, $class;
|
|
||||||
}
|
|
||||||
|
|
||||||
sub Vars {
|
|
||||||
my $self = shift;
|
|
||||||
my $pairs;
|
|
||||||
if ($ENV{CONTENT_LENGTH}) {
|
|
||||||
$pairs = do { local $/; <STDIN> };
|
|
||||||
} else {
|
|
||||||
$pairs = $ENV{QUERY_STRING};
|
|
||||||
}
|
|
||||||
my $vars = {};
|
|
||||||
foreach my $kv (split(/&/, $pairs)) {
|
|
||||||
my ($k, $v) = split(/=/, $kv, 2);
|
|
||||||
$vars->{_urldecode($k)} = _urldecode($v);
|
|
||||||
}
|
|
||||||
return $vars;
|
|
||||||
}
|
|
||||||
|
|
||||||
sub _urldecode {
|
|
||||||
my $v = shift;
|
|
||||||
$v =~ tr/+/ /;
|
|
||||||
$v =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
|
|
||||||
return $v;
|
|
||||||
}
|
|
||||||
1
Godeps/_workspace/src/github.com/MSOpenTech/azure-sdk-for-go/core/http/testdata/file
generated
vendored
1
Godeps/_workspace/src/github.com/MSOpenTech/azure-sdk-for-go/core/http/testdata/file
generated
vendored
|
|
@ -1 +0,0 @@
|
||||||
0123456789
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
index.html says hello
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
body {}
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
language: go
|
|
||||||
go: 1.1
|
|
||||||
|
|
||||||
script:
|
|
||||||
- go vet ./...
|
|
||||||
- go test -v ./...
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
Copyright (C) 2013 Jeremy Saenz
|
|
||||||
All Rights Reserved.
|
|
||||||
|
|
||||||
MIT LICENSE
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
||||||
this software and associated documentation files (the "Software"), to deal in
|
|
||||||
the Software without restriction, including without limitation the rights to
|
|
||||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
||||||
the Software, and to permit persons to whom the Software is furnished to do so,
|
|
||||||
subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in all
|
|
||||||
copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
||||||
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
||||||
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
||||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
||||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
||||||
|
|
@ -1,298 +0,0 @@
|
||||||
[](https://travis-ci.org/codegangsta/cli)
|
|
||||||
|
|
||||||
# cli.go
|
|
||||||
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.
|
|
||||||
|
|
||||||
You can view the API docs here:
|
|
||||||
http://godoc.org/github.com/codegangsta/cli
|
|
||||||
|
|
||||||
## Overview
|
|
||||||
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.
|
|
||||||
|
|
||||||
**This is where cli.go comes into play.** cli.go makes command line programming fun, organized, and expressive!
|
|
||||||
|
|
||||||
## Installation
|
|
||||||
Make sure you have a working Go environment (go 1.1 is *required*). [See the install instructions](http://golang.org/doc/install.html).
|
|
||||||
|
|
||||||
To install `cli.go`, simply run:
|
|
||||||
```
|
|
||||||
$ go get github.com/codegangsta/cli
|
|
||||||
```
|
|
||||||
|
|
||||||
Make sure your `PATH` includes to the `$GOPATH/bin` directory so your commands can be easily used:
|
|
||||||
```
|
|
||||||
export PATH=$PATH:$GOPATH/bin
|
|
||||||
```
|
|
||||||
|
|
||||||
## Getting Started
|
|
||||||
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()`.
|
|
||||||
|
|
||||||
``` go
|
|
||||||
package main
|
|
||||||
|
|
||||||
import (
|
|
||||||
"os"
|
|
||||||
"github.com/codegangsta/cli"
|
|
||||||
)
|
|
||||||
|
|
||||||
func main() {
|
|
||||||
cli.NewApp().Run(os.Args)
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
|
|
||||||
|
|
||||||
``` go
|
|
||||||
package main
|
|
||||||
|
|
||||||
import (
|
|
||||||
"os"
|
|
||||||
"github.com/codegangsta/cli"
|
|
||||||
)
|
|
||||||
|
|
||||||
func main() {
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "boom"
|
|
||||||
app.Usage = "make an explosive entrance"
|
|
||||||
app.Action = func(c *cli.Context) {
|
|
||||||
println("boom! I say!")
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run(os.Args)
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
Running this already gives you a ton of functionality, plus support for things like subcommands and flags, which are covered below.
|
|
||||||
|
|
||||||
## Example
|
|
||||||
|
|
||||||
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!
|
|
||||||
|
|
||||||
Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
|
|
||||||
|
|
||||||
``` go
|
|
||||||
package main
|
|
||||||
|
|
||||||
import (
|
|
||||||
"os"
|
|
||||||
"github.com/codegangsta/cli"
|
|
||||||
)
|
|
||||||
|
|
||||||
func main() {
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "greet"
|
|
||||||
app.Usage = "fight the loneliness!"
|
|
||||||
app.Action = func(c *cli.Context) {
|
|
||||||
println("Hello friend!")
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run(os.Args)
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
Install our command to the `$GOPATH/bin` directory:
|
|
||||||
|
|
||||||
```
|
|
||||||
$ go install
|
|
||||||
```
|
|
||||||
|
|
||||||
Finally run our new command:
|
|
||||||
|
|
||||||
```
|
|
||||||
$ greet
|
|
||||||
Hello friend!
|
|
||||||
```
|
|
||||||
|
|
||||||
cli.go also generates some bitchass help text:
|
|
||||||
```
|
|
||||||
$ greet help
|
|
||||||
NAME:
|
|
||||||
greet - fight the loneliness!
|
|
||||||
|
|
||||||
USAGE:
|
|
||||||
greet [global options] command [command options] [arguments...]
|
|
||||||
|
|
||||||
VERSION:
|
|
||||||
0.0.0
|
|
||||||
|
|
||||||
COMMANDS:
|
|
||||||
help, h Shows a list of commands or help for one command
|
|
||||||
|
|
||||||
GLOBAL OPTIONS
|
|
||||||
--version Shows version information
|
|
||||||
```
|
|
||||||
|
|
||||||
### Arguments
|
|
||||||
You can lookup arguments by calling the `Args` function on `cli.Context`.
|
|
||||||
|
|
||||||
``` go
|
|
||||||
...
|
|
||||||
app.Action = func(c *cli.Context) {
|
|
||||||
println("Hello", c.Args()[0])
|
|
||||||
}
|
|
||||||
...
|
|
||||||
```
|
|
||||||
|
|
||||||
### Flags
|
|
||||||
Setting and querying flags is simple.
|
|
||||||
``` go
|
|
||||||
...
|
|
||||||
app.Flags = []cli.Flag {
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "lang",
|
|
||||||
Value: "english",
|
|
||||||
Usage: "language for the greeting",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
app.Action = func(c *cli.Context) {
|
|
||||||
name := "someone"
|
|
||||||
if len(c.Args()) > 0 {
|
|
||||||
name = c.Args()[0]
|
|
||||||
}
|
|
||||||
if c.String("lang") == "spanish" {
|
|
||||||
println("Hola", name)
|
|
||||||
} else {
|
|
||||||
println("Hello", name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
...
|
|
||||||
```
|
|
||||||
|
|
||||||
#### Alternate Names
|
|
||||||
|
|
||||||
You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
|
|
||||||
|
|
||||||
``` go
|
|
||||||
app.Flags = []cli.Flag {
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "lang, l",
|
|
||||||
Value: "english",
|
|
||||||
Usage: "language for the greeting",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
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.
|
|
||||||
|
|
||||||
#### Values from the Environment
|
|
||||||
|
|
||||||
You can also have the default value set from the environment via `EnvVar`. e.g.
|
|
||||||
|
|
||||||
``` go
|
|
||||||
app.Flags = []cli.Flag {
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "lang, l",
|
|
||||||
Value: "english",
|
|
||||||
Usage: "language for the greeting",
|
|
||||||
EnvVar: "APP_LANG",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
The `EnvVar` may also be given as a comma-delimited "cascade", where the first environment variable that resolves is used as the default.
|
|
||||||
|
|
||||||
``` go
|
|
||||||
app.Flags = []cli.Flag {
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "lang, l",
|
|
||||||
Value: "english",
|
|
||||||
Usage: "language for the greeting",
|
|
||||||
EnvVar: "LEGACY_COMPAT_LANG,APP_LANG,LANG",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
### Subcommands
|
|
||||||
|
|
||||||
Subcommands can be defined for a more git-like command line app.
|
|
||||||
```go
|
|
||||||
...
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "add",
|
|
||||||
ShortName: "a",
|
|
||||||
Usage: "add a task to the list",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("added task: ", c.Args().First())
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "complete",
|
|
||||||
ShortName: "c",
|
|
||||||
Usage: "complete a task on the list",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("completed task: ", c.Args().First())
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "template",
|
|
||||||
ShortName: "r",
|
|
||||||
Usage: "options for task templates",
|
|
||||||
Subcommands: []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "add",
|
|
||||||
Usage: "add a new template",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("new task template: ", c.Args().First())
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "remove",
|
|
||||||
Usage: "remove an existing template",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("removed task template: ", c.Args().First())
|
|
||||||
},
|
|
||||||
},
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
...
|
|
||||||
```
|
|
||||||
|
|
||||||
### Bash Completion
|
|
||||||
|
|
||||||
You can enable completion commands by setting the `EnableBashCompletion`
|
|
||||||
flag on the `App` object. By default, this setting will only auto-complete to
|
|
||||||
show an app's subcommands, but you can write your own completion methods for
|
|
||||||
the App or its subcommands.
|
|
||||||
```go
|
|
||||||
...
|
|
||||||
var tasks = []string{"cook", "clean", "laundry", "eat", "sleep", "code"}
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.EnableBashCompletion = true
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "complete",
|
|
||||||
ShortName: "c",
|
|
||||||
Usage: "complete a task on the list",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("completed task: ", c.Args().First())
|
|
||||||
},
|
|
||||||
BashComplete: func(c *cli.Context) {
|
|
||||||
// This will complete if no args are passed
|
|
||||||
if len(c.Args()) > 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
for _, t := range tasks {
|
|
||||||
fmt.Println(t)
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
...
|
|
||||||
```
|
|
||||||
|
|
||||||
#### To Enable
|
|
||||||
|
|
||||||
Source the `autocomplete/bash_autocomplete` file in your `.bashrc` file while
|
|
||||||
setting the `PROG` variable to the name of your program:
|
|
||||||
|
|
||||||
`PROG=myprogram source /.../cli/autocomplete/bash_autocomplete`
|
|
||||||
|
|
||||||
|
|
||||||
## Contribution Guidelines
|
|
||||||
Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.
|
|
||||||
|
|
||||||
If you are have contributed something significant to the project, I will most likely add you as a collaborator. As a collaborator you are given the ability to merge others pull requests. It is very important that new code does not break existing code, so be careful about what code you do choose to merge. If you have any questions feel free to link @codegangsta to the issue in question and we can review it together.
|
|
||||||
|
|
||||||
If you feel like you have contributed to the project but have not yet been added as a collaborator, I probably forgot to add you. Hit @codegangsta up over email and we will get it figured out.
|
|
||||||
|
|
@ -1,275 +0,0 @@
|
||||||
package cli
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"text/tabwriter"
|
|
||||||
"text/template"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// App is the main structure of a cli application. It is recomended that
|
|
||||||
// and app be created with the cli.NewApp() function
|
|
||||||
type App struct {
|
|
||||||
// The name of the program. Defaults to os.Args[0]
|
|
||||||
Name string
|
|
||||||
// Description of the program.
|
|
||||||
Usage string
|
|
||||||
// Version of the program
|
|
||||||
Version string
|
|
||||||
// List of commands to execute
|
|
||||||
Commands []Command
|
|
||||||
// List of flags to parse
|
|
||||||
Flags []Flag
|
|
||||||
// Boolean to enable bash completion commands
|
|
||||||
EnableBashCompletion bool
|
|
||||||
// Boolean to hide built-in help command
|
|
||||||
HideHelp bool
|
|
||||||
// Boolean to hide built-in version flag
|
|
||||||
HideVersion bool
|
|
||||||
// An action to execute when the bash-completion flag is set
|
|
||||||
BashComplete func(context *Context)
|
|
||||||
// An action to execute before any subcommands are run, but after the context is ready
|
|
||||||
// If a non-nil error is returned, no subcommands are run
|
|
||||||
Before func(context *Context) error
|
|
||||||
// The action to execute when no subcommands are specified
|
|
||||||
Action func(context *Context)
|
|
||||||
// Execute this function if the proper command cannot be found
|
|
||||||
CommandNotFound func(context *Context, command string)
|
|
||||||
// Compilation date
|
|
||||||
Compiled time.Time
|
|
||||||
// Author
|
|
||||||
Author string
|
|
||||||
// Author e-mail
|
|
||||||
Email string
|
|
||||||
// Writer writer to write output to
|
|
||||||
Writer io.Writer
|
|
||||||
}
|
|
||||||
|
|
||||||
// Tries to find out when this binary was compiled.
|
|
||||||
// Returns the current time if it fails to find it.
|
|
||||||
func compileTime() time.Time {
|
|
||||||
info, err := os.Stat(os.Args[0])
|
|
||||||
if err != nil {
|
|
||||||
return time.Now()
|
|
||||||
}
|
|
||||||
return info.ModTime()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
|
|
||||||
func NewApp() *App {
|
|
||||||
return &App{
|
|
||||||
Name: os.Args[0],
|
|
||||||
Usage: "A new cli application",
|
|
||||||
Version: "0.0.0",
|
|
||||||
BashComplete: DefaultAppComplete,
|
|
||||||
Action: helpCommand.Action,
|
|
||||||
Compiled: compileTime(),
|
|
||||||
Author: "Author",
|
|
||||||
Email: "unknown@email",
|
|
||||||
Writer: os.Stdout,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
|
|
||||||
func (a *App) Run(arguments []string) error {
|
|
||||||
if HelpPrinter == nil {
|
|
||||||
defer func() {
|
|
||||||
HelpPrinter = nil
|
|
||||||
}()
|
|
||||||
|
|
||||||
HelpPrinter = func(templ string, data interface{}) {
|
|
||||||
w := tabwriter.NewWriter(a.Writer, 0, 8, 1, '\t', 0)
|
|
||||||
t := template.Must(template.New("help").Parse(templ))
|
|
||||||
err := t.Execute(w, data)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
w.Flush()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// append help to commands
|
|
||||||
if a.Command(helpCommand.Name) == nil && !a.HideHelp {
|
|
||||||
a.Commands = append(a.Commands, helpCommand)
|
|
||||||
if (HelpFlag != BoolFlag{}) {
|
|
||||||
a.appendFlag(HelpFlag)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//append version/help flags
|
|
||||||
if a.EnableBashCompletion {
|
|
||||||
a.appendFlag(BashCompletionFlag)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !a.HideVersion {
|
|
||||||
a.appendFlag(VersionFlag)
|
|
||||||
}
|
|
||||||
|
|
||||||
// parse flags
|
|
||||||
set := flagSet(a.Name, a.Flags)
|
|
||||||
set.SetOutput(ioutil.Discard)
|
|
||||||
err := set.Parse(arguments[1:])
|
|
||||||
nerr := normalizeFlags(a.Flags, set)
|
|
||||||
if nerr != nil {
|
|
||||||
fmt.Fprintln(a.Writer, nerr)
|
|
||||||
context := NewContext(a, set, set)
|
|
||||||
ShowAppHelp(context)
|
|
||||||
fmt.Fprintln(a.Writer)
|
|
||||||
return nerr
|
|
||||||
}
|
|
||||||
context := NewContext(a, set, set)
|
|
||||||
|
|
||||||
if err != nil {
|
|
||||||
fmt.Fprintf(a.Writer, "Incorrect Usage.\n\n")
|
|
||||||
ShowAppHelp(context)
|
|
||||||
fmt.Fprintln(a.Writer)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if checkCompletions(context) {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if checkHelp(context) {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if checkVersion(context) {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if a.Before != nil {
|
|
||||||
err := a.Before(context)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
args := context.Args()
|
|
||||||
if args.Present() {
|
|
||||||
name := args.First()
|
|
||||||
c := a.Command(name)
|
|
||||||
if c != nil {
|
|
||||||
return c.Run(context)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run default Action
|
|
||||||
a.Action(context)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Another entry point to the cli app, takes care of passing arguments and error handling
|
|
||||||
func (a *App) RunAndExitOnError() {
|
|
||||||
if err := a.Run(os.Args); err != nil {
|
|
||||||
fmt.Fprintln(os.Stderr, err)
|
|
||||||
os.Exit(1)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
|
|
||||||
func (a *App) RunAsSubcommand(ctx *Context) error {
|
|
||||||
// append help to commands
|
|
||||||
if len(a.Commands) > 0 {
|
|
||||||
if a.Command(helpCommand.Name) == nil && !a.HideHelp {
|
|
||||||
a.Commands = append(a.Commands, helpCommand)
|
|
||||||
if (HelpFlag != BoolFlag{}) {
|
|
||||||
a.appendFlag(HelpFlag)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// append flags
|
|
||||||
if a.EnableBashCompletion {
|
|
||||||
a.appendFlag(BashCompletionFlag)
|
|
||||||
}
|
|
||||||
|
|
||||||
// parse flags
|
|
||||||
set := flagSet(a.Name, a.Flags)
|
|
||||||
set.SetOutput(ioutil.Discard)
|
|
||||||
err := set.Parse(ctx.Args().Tail())
|
|
||||||
nerr := normalizeFlags(a.Flags, set)
|
|
||||||
context := NewContext(a, set, ctx.globalSet)
|
|
||||||
|
|
||||||
if nerr != nil {
|
|
||||||
fmt.Fprintln(a.Writer, nerr)
|
|
||||||
if len(a.Commands) > 0 {
|
|
||||||
ShowSubcommandHelp(context)
|
|
||||||
} else {
|
|
||||||
ShowCommandHelp(ctx, context.Args().First())
|
|
||||||
}
|
|
||||||
fmt.Fprintln(a.Writer)
|
|
||||||
return nerr
|
|
||||||
}
|
|
||||||
|
|
||||||
if err != nil {
|
|
||||||
fmt.Fprintf(a.Writer, "Incorrect Usage.\n\n")
|
|
||||||
ShowSubcommandHelp(context)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if checkCompletions(context) {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(a.Commands) > 0 {
|
|
||||||
if checkSubcommandHelp(context) {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if checkCommandHelp(ctx, context.Args().First()) {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if a.Before != nil {
|
|
||||||
err := a.Before(context)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
args := context.Args()
|
|
||||||
if args.Present() {
|
|
||||||
name := args.First()
|
|
||||||
c := a.Command(name)
|
|
||||||
if c != nil {
|
|
||||||
return c.Run(context)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run default Action
|
|
||||||
a.Action(context)
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns the named command on App. Returns nil if the command does not exist
|
|
||||||
func (a *App) Command(name string) *Command {
|
|
||||||
for _, c := range a.Commands {
|
|
||||||
if c.HasName(name) {
|
|
||||||
return &c
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (a *App) hasFlag(flag Flag) bool {
|
|
||||||
for _, f := range a.Flags {
|
|
||||||
if flag == f {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (a *App) appendFlag(flag Flag) {
|
|
||||||
if !a.hasFlag(flag) {
|
|
||||||
a.Flags = append(a.Flags, flag)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,554 +0,0 @@
|
||||||
package cli_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"flag"
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/codegangsta/cli"
|
|
||||||
)
|
|
||||||
|
|
||||||
func ExampleApp() {
|
|
||||||
// set args for examples sake
|
|
||||||
os.Args = []string{"greet", "--name", "Jeremy"}
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "greet"
|
|
||||||
app.Flags = []cli.Flag{
|
|
||||||
cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
|
|
||||||
}
|
|
||||||
app.Action = func(c *cli.Context) {
|
|
||||||
fmt.Printf("Hello %v\n", c.String("name"))
|
|
||||||
}
|
|
||||||
app.Run(os.Args)
|
|
||||||
// Output:
|
|
||||||
// Hello Jeremy
|
|
||||||
}
|
|
||||||
|
|
||||||
func ExampleAppSubcommand() {
|
|
||||||
// set args for examples sake
|
|
||||||
os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "say"
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "hello",
|
|
||||||
ShortName: "hi",
|
|
||||||
Usage: "use it to see a description",
|
|
||||||
Description: "This is how we describe hello the function",
|
|
||||||
Subcommands: []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "english",
|
|
||||||
ShortName: "en",
|
|
||||||
Usage: "sends a greeting in english",
|
|
||||||
Description: "greets someone in english",
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "name",
|
|
||||||
Value: "Bob",
|
|
||||||
Usage: "Name of the person to greet",
|
|
||||||
},
|
|
||||||
},
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
fmt.Println("Hello,", c.String("name"))
|
|
||||||
},
|
|
||||||
},
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run(os.Args)
|
|
||||||
// Output:
|
|
||||||
// Hello, Jeremy
|
|
||||||
}
|
|
||||||
|
|
||||||
func ExampleAppHelp() {
|
|
||||||
// set args for examples sake
|
|
||||||
os.Args = []string{"greet", "h", "describeit"}
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "greet"
|
|
||||||
app.Flags = []cli.Flag{
|
|
||||||
cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
|
|
||||||
}
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "describeit",
|
|
||||||
ShortName: "d",
|
|
||||||
Usage: "use it to see a description",
|
|
||||||
Description: "This is how we describe describeit the function",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
fmt.Printf("i like to describe things")
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
app.Run(os.Args)
|
|
||||||
// Output:
|
|
||||||
// NAME:
|
|
||||||
// describeit - use it to see a description
|
|
||||||
//
|
|
||||||
// USAGE:
|
|
||||||
// command describeit [arguments...]
|
|
||||||
//
|
|
||||||
// DESCRIPTION:
|
|
||||||
// This is how we describe describeit the function
|
|
||||||
}
|
|
||||||
|
|
||||||
func ExampleAppBashComplete() {
|
|
||||||
// set args for examples sake
|
|
||||||
os.Args = []string{"greet", "--generate-bash-completion"}
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "greet"
|
|
||||||
app.EnableBashCompletion = true
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "describeit",
|
|
||||||
ShortName: "d",
|
|
||||||
Usage: "use it to see a description",
|
|
||||||
Description: "This is how we describe describeit the function",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
fmt.Printf("i like to describe things")
|
|
||||||
},
|
|
||||||
}, {
|
|
||||||
Name: "next",
|
|
||||||
Usage: "next example",
|
|
||||||
Description: "more stuff to see when generating bash completion",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
fmt.Printf("the next example")
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run(os.Args)
|
|
||||||
// Output:
|
|
||||||
// describeit
|
|
||||||
// d
|
|
||||||
// next
|
|
||||||
// help
|
|
||||||
// h
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_Run(t *testing.T) {
|
|
||||||
s := ""
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Action = func(c *cli.Context) {
|
|
||||||
s = s + c.Args().First()
|
|
||||||
}
|
|
||||||
|
|
||||||
err := app.Run([]string{"command", "foo"})
|
|
||||||
expect(t, err, nil)
|
|
||||||
err = app.Run([]string{"command", "bar"})
|
|
||||||
expect(t, err, nil)
|
|
||||||
expect(t, s, "foobar")
|
|
||||||
}
|
|
||||||
|
|
||||||
var commandAppTests = []struct {
|
|
||||||
name string
|
|
||||||
expected bool
|
|
||||||
}{
|
|
||||||
{"foobar", true},
|
|
||||||
{"batbaz", true},
|
|
||||||
{"b", true},
|
|
||||||
{"f", true},
|
|
||||||
{"bat", false},
|
|
||||||
{"nothing", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_Command(t *testing.T) {
|
|
||||||
app := cli.NewApp()
|
|
||||||
fooCommand := cli.Command{Name: "foobar", ShortName: "f"}
|
|
||||||
batCommand := cli.Command{Name: "batbaz", ShortName: "b"}
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
fooCommand,
|
|
||||||
batCommand,
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, test := range commandAppTests {
|
|
||||||
expect(t, app.Command(test.name) != nil, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
|
|
||||||
var parsedOption, firstArg string
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
command := cli.Command{
|
|
||||||
Name: "cmd",
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
|
|
||||||
},
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
parsedOption = c.String("option")
|
|
||||||
firstArg = c.Args().First()
|
|
||||||
},
|
|
||||||
}
|
|
||||||
app.Commands = []cli.Command{command}
|
|
||||||
|
|
||||||
app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
|
|
||||||
|
|
||||||
expect(t, parsedOption, "my-option")
|
|
||||||
expect(t, firstArg, "my-arg")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
|
|
||||||
var context *cli.Context
|
|
||||||
|
|
||||||
a := cli.NewApp()
|
|
||||||
a.Commands = []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "foo",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
context = c
|
|
||||||
},
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "lang",
|
|
||||||
Value: "english",
|
|
||||||
Usage: "language for the greeting",
|
|
||||||
},
|
|
||||||
},
|
|
||||||
Before: func(_ *cli.Context) error { return nil },
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
|
|
||||||
|
|
||||||
expect(t, context.Args().Get(0), "abcd")
|
|
||||||
expect(t, context.String("lang"), "spanish")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
|
|
||||||
var parsedOption string
|
|
||||||
var args []string
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
command := cli.Command{
|
|
||||||
Name: "cmd",
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
|
|
||||||
},
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
parsedOption = c.String("option")
|
|
||||||
args = c.Args()
|
|
||||||
},
|
|
||||||
}
|
|
||||||
app.Commands = []cli.Command{command}
|
|
||||||
|
|
||||||
app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"})
|
|
||||||
|
|
||||||
expect(t, parsedOption, "my-option")
|
|
||||||
expect(t, args[0], "my-arg")
|
|
||||||
expect(t, args[1], "--")
|
|
||||||
expect(t, args[2], "--notARealFlag")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
|
|
||||||
var args []string
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
command := cli.Command{
|
|
||||||
Name: "cmd",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
args = c.Args()
|
|
||||||
},
|
|
||||||
}
|
|
||||||
app.Commands = []cli.Command{command}
|
|
||||||
|
|
||||||
app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"})
|
|
||||||
|
|
||||||
expect(t, args[0], "my-arg")
|
|
||||||
expect(t, args[1], "--")
|
|
||||||
expect(t, args[2], "notAFlagAtAll")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_Float64Flag(t *testing.T) {
|
|
||||||
var meters float64
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Flags = []cli.Flag{
|
|
||||||
cli.Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
|
|
||||||
}
|
|
||||||
app.Action = func(c *cli.Context) {
|
|
||||||
meters = c.Float64("height")
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run([]string{"", "--height", "1.93"})
|
|
||||||
expect(t, meters, 1.93)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_ParseSliceFlags(t *testing.T) {
|
|
||||||
var parsedOption, firstArg string
|
|
||||||
var parsedIntSlice []int
|
|
||||||
var parsedStringSlice []string
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
command := cli.Command{
|
|
||||||
Name: "cmd",
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.IntSliceFlag{Name: "p", Value: &cli.IntSlice{}, Usage: "set one or more ip addr"},
|
|
||||||
cli.StringSliceFlag{Name: "ip", Value: &cli.StringSlice{}, Usage: "set one or more ports to open"},
|
|
||||||
},
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
parsedIntSlice = c.IntSlice("p")
|
|
||||||
parsedStringSlice = c.StringSlice("ip")
|
|
||||||
parsedOption = c.String("option")
|
|
||||||
firstArg = c.Args().First()
|
|
||||||
},
|
|
||||||
}
|
|
||||||
app.Commands = []cli.Command{command}
|
|
||||||
|
|
||||||
app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
|
|
||||||
|
|
||||||
IntsEquals := func(a, b []int) bool {
|
|
||||||
if len(a) != len(b) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
for i, v := range a {
|
|
||||||
if v != b[i] {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
StrsEquals := func(a, b []string) bool {
|
|
||||||
if len(a) != len(b) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
for i, v := range a {
|
|
||||||
if v != b[i] {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
var expectedIntSlice = []int{22, 80}
|
|
||||||
var expectedStringSlice = []string{"8.8.8.8", "8.8.4.4"}
|
|
||||||
|
|
||||||
if !IntsEquals(parsedIntSlice, expectedIntSlice) {
|
|
||||||
t.Errorf("%v does not match %v", parsedIntSlice, expectedIntSlice)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !StrsEquals(parsedStringSlice, expectedStringSlice) {
|
|
||||||
t.Errorf("%v does not match %v", parsedStringSlice, expectedStringSlice)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_DefaultStdout(t *testing.T) {
|
|
||||||
app := cli.NewApp()
|
|
||||||
|
|
||||||
if app.Writer != os.Stdout {
|
|
||||||
t.Error("Default output writer not set.")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type mockWriter struct {
|
|
||||||
written []byte
|
|
||||||
}
|
|
||||||
|
|
||||||
func (fw *mockWriter) Write(p []byte) (n int, err error) {
|
|
||||||
if fw.written == nil {
|
|
||||||
fw.written = p
|
|
||||||
} else {
|
|
||||||
fw.written = append(fw.written, p...)
|
|
||||||
}
|
|
||||||
|
|
||||||
return len(p), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (fw *mockWriter) GetWritten() (b []byte) {
|
|
||||||
return fw.written
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_SetStdout(t *testing.T) {
|
|
||||||
w := &mockWriter{}
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "test"
|
|
||||||
app.Writer = w
|
|
||||||
|
|
||||||
err := app.Run([]string{"help"})
|
|
||||||
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Run error: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(w.written) == 0 {
|
|
||||||
t.Error("App did not write output to desired writer.")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApp_BeforeFunc(t *testing.T) {
|
|
||||||
beforeRun, subcommandRun := false, false
|
|
||||||
beforeError := fmt.Errorf("fail")
|
|
||||||
var err error
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
|
|
||||||
app.Before = func(c *cli.Context) error {
|
|
||||||
beforeRun = true
|
|
||||||
s := c.String("opt")
|
|
||||||
if s == "fail" {
|
|
||||||
return beforeError
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
cli.Command{
|
|
||||||
Name: "sub",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
subcommandRun = true
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Flags = []cli.Flag{
|
|
||||||
cli.StringFlag{Name: "opt"},
|
|
||||||
}
|
|
||||||
|
|
||||||
// run with the Before() func succeeding
|
|
||||||
err = app.Run([]string{"command", "--opt", "succeed", "sub"})
|
|
||||||
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Run error: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if beforeRun == false {
|
|
||||||
t.Errorf("Before() not executed when expected")
|
|
||||||
}
|
|
||||||
|
|
||||||
if subcommandRun == false {
|
|
||||||
t.Errorf("Subcommand not executed when expected")
|
|
||||||
}
|
|
||||||
|
|
||||||
// reset
|
|
||||||
beforeRun, subcommandRun = false, false
|
|
||||||
|
|
||||||
// run with the Before() func failing
|
|
||||||
err = app.Run([]string{"command", "--opt", "fail", "sub"})
|
|
||||||
|
|
||||||
// should be the same error produced by the Before func
|
|
||||||
if err != beforeError {
|
|
||||||
t.Errorf("Run error expected, but not received")
|
|
||||||
}
|
|
||||||
|
|
||||||
if beforeRun == false {
|
|
||||||
t.Errorf("Before() not executed when expected")
|
|
||||||
}
|
|
||||||
|
|
||||||
if subcommandRun == true {
|
|
||||||
t.Errorf("Subcommand executed when NOT expected")
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestAppNoHelpFlag(t *testing.T) {
|
|
||||||
oldFlag := cli.HelpFlag
|
|
||||||
defer func() {
|
|
||||||
cli.HelpFlag = oldFlag
|
|
||||||
}()
|
|
||||||
|
|
||||||
cli.HelpFlag = cli.BoolFlag{}
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
err := app.Run([]string{"test", "-h"})
|
|
||||||
|
|
||||||
if err != flag.ErrHelp {
|
|
||||||
t.Errorf("expected error about missing help flag, but got: %s (%T)", err, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestAppHelpPrinter(t *testing.T) {
|
|
||||||
oldPrinter := cli.HelpPrinter
|
|
||||||
defer func() {
|
|
||||||
cli.HelpPrinter = oldPrinter
|
|
||||||
}()
|
|
||||||
|
|
||||||
var wasCalled = false
|
|
||||||
cli.HelpPrinter = func(template string, data interface{}) {
|
|
||||||
wasCalled = true
|
|
||||||
}
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Run([]string{"-h"})
|
|
||||||
|
|
||||||
if wasCalled == false {
|
|
||||||
t.Errorf("Help printer expected to be called, but was not")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestAppVersionPrinter(t *testing.T) {
|
|
||||||
oldPrinter := cli.VersionPrinter
|
|
||||||
defer func() {
|
|
||||||
cli.VersionPrinter = oldPrinter
|
|
||||||
}()
|
|
||||||
|
|
||||||
var wasCalled = false
|
|
||||||
cli.VersionPrinter = func(c *cli.Context) {
|
|
||||||
wasCalled = true
|
|
||||||
}
|
|
||||||
|
|
||||||
app := cli.NewApp()
|
|
||||||
ctx := cli.NewContext(app, nil, nil)
|
|
||||||
cli.ShowVersion(ctx)
|
|
||||||
|
|
||||||
if wasCalled == false {
|
|
||||||
t.Errorf("Version printer expected to be called, but was not")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestAppCommandNotFound(t *testing.T) {
|
|
||||||
beforeRun, subcommandRun := false, false
|
|
||||||
app := cli.NewApp()
|
|
||||||
|
|
||||||
app.CommandNotFound = func(c *cli.Context, command string) {
|
|
||||||
beforeRun = true
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
cli.Command{
|
|
||||||
Name: "bar",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
subcommandRun = true
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run([]string{"command", "foo"})
|
|
||||||
|
|
||||||
expect(t, beforeRun, true)
|
|
||||||
expect(t, subcommandRun, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGlobalFlagsInSubcommands(t *testing.T) {
|
|
||||||
subcommandRun := false
|
|
||||||
app := cli.NewApp()
|
|
||||||
|
|
||||||
app.Flags = []cli.Flag{
|
|
||||||
cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
cli.Command{
|
|
||||||
Name: "foo",
|
|
||||||
Subcommands: []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "bar",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
if c.GlobalBool("debug") {
|
|
||||||
subcommandRun = true
|
|
||||||
}
|
|
||||||
},
|
|
||||||
},
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run([]string{"command", "-d", "foo", "bar"})
|
|
||||||
|
|
||||||
expect(t, subcommandRun, true)
|
|
||||||
}
|
|
||||||
13
Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete
generated
vendored
13
Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete
generated
vendored
|
|
@ -1,13 +0,0 @@
|
||||||
#! /bin/bash
|
|
||||||
|
|
||||||
_cli_bash_autocomplete() {
|
|
||||||
local cur prev opts base
|
|
||||||
COMPREPLY=()
|
|
||||||
cur="${COMP_WORDS[COMP_CWORD]}"
|
|
||||||
prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
||||||
opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
|
|
||||||
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
complete -F _cli_bash_autocomplete $PROG
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
autoload -U compinit && compinit
|
|
||||||
autoload -U bashcompinit && bashcompinit
|
|
||||||
|
|
||||||
script_dir=$(dirname $0)
|
|
||||||
source ${script_dir}/bash_autocomplete
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
// Package cli provides a minimal framework for creating and organizing command line
|
|
||||||
// Go applications. cli is designed to be easy to understand and write, the most simple
|
|
||||||
// cli application can be written as follows:
|
|
||||||
// func main() {
|
|
||||||
// cli.NewApp().Run(os.Args)
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// Of course this application does not do much, so let's make this an actual application:
|
|
||||||
// func main() {
|
|
||||||
// app := cli.NewApp()
|
|
||||||
// app.Name = "greet"
|
|
||||||
// app.Usage = "say a greeting"
|
|
||||||
// app.Action = func(c *cli.Context) {
|
|
||||||
// println("Greetings")
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// app.Run(os.Args)
|
|
||||||
// }
|
|
||||||
package cli
|
|
||||||
|
|
@ -1,100 +0,0 @@
|
||||||
package cli_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"os"
|
|
||||||
|
|
||||||
"github.com/codegangsta/cli"
|
|
||||||
)
|
|
||||||
|
|
||||||
func Example() {
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "todo"
|
|
||||||
app.Usage = "task list on the command line"
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "add",
|
|
||||||
ShortName: "a",
|
|
||||||
Usage: "add a task to the list",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("added task: ", c.Args().First())
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "complete",
|
|
||||||
ShortName: "c",
|
|
||||||
Usage: "complete a task on the list",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("completed task: ", c.Args().First())
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run(os.Args)
|
|
||||||
}
|
|
||||||
|
|
||||||
func ExampleSubcommand() {
|
|
||||||
app := cli.NewApp()
|
|
||||||
app.Name = "say"
|
|
||||||
app.Commands = []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "hello",
|
|
||||||
ShortName: "hi",
|
|
||||||
Usage: "use it to see a description",
|
|
||||||
Description: "This is how we describe hello the function",
|
|
||||||
Subcommands: []cli.Command{
|
|
||||||
{
|
|
||||||
Name: "english",
|
|
||||||
ShortName: "en",
|
|
||||||
Usage: "sends a greeting in english",
|
|
||||||
Description: "greets someone in english",
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "name",
|
|
||||||
Value: "Bob",
|
|
||||||
Usage: "Name of the person to greet",
|
|
||||||
},
|
|
||||||
},
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("Hello, ", c.String("name"))
|
|
||||||
},
|
|
||||||
}, {
|
|
||||||
Name: "spanish",
|
|
||||||
ShortName: "sp",
|
|
||||||
Usage: "sends a greeting in spanish",
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "surname",
|
|
||||||
Value: "Jones",
|
|
||||||
Usage: "Surname of the person to greet",
|
|
||||||
},
|
|
||||||
},
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("Hola, ", c.String("surname"))
|
|
||||||
},
|
|
||||||
}, {
|
|
||||||
Name: "french",
|
|
||||||
ShortName: "fr",
|
|
||||||
Usage: "sends a greeting in french",
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{
|
|
||||||
Name: "nickname",
|
|
||||||
Value: "Stevie",
|
|
||||||
Usage: "Nickname of the person to greet",
|
|
||||||
},
|
|
||||||
},
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("Bonjour, ", c.String("nickname"))
|
|
||||||
},
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}, {
|
|
||||||
Name: "bye",
|
|
||||||
Usage: "says goodbye",
|
|
||||||
Action: func(c *cli.Context) {
|
|
||||||
println("bye")
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
app.Run(os.Args)
|
|
||||||
}
|
|
||||||
|
|
@ -1,156 +0,0 @@
|
||||||
package cli
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"io/ioutil"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Command is a subcommand for a cli.App.
|
|
||||||
type Command struct {
|
|
||||||
// The name of the command
|
|
||||||
Name string
|
|
||||||
// short name of the command. Typically one character
|
|
||||||
ShortName string
|
|
||||||
// A short description of the usage of this command
|
|
||||||
Usage string
|
|
||||||
// A longer explanation of how the command works
|
|
||||||
Description string
|
|
||||||
// The function to call when checking for bash command completions
|
|
||||||
BashComplete func(context *Context)
|
|
||||||
// An action to execute before any sub-subcommands are run, but after the context is ready
|
|
||||||
// If a non-nil error is returned, no sub-subcommands are run
|
|
||||||
Before func(context *Context) error
|
|
||||||
// The function to call when this command is invoked
|
|
||||||
Action func(context *Context)
|
|
||||||
// List of child commands
|
|
||||||
Subcommands []Command
|
|
||||||
// List of flags to parse
|
|
||||||
Flags []Flag
|
|
||||||
// Treat all flags as normal arguments if true
|
|
||||||
SkipFlagParsing bool
|
|
||||||
// Boolean to hide built-in help command
|
|
||||||
HideHelp bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// Invokes the command given the context, parses ctx.Args() to generate command-specific flags
|
|
||||||
func (c Command) Run(ctx *Context) error {
|
|
||||||
|
|
||||||
if len(c.Subcommands) > 0 || c.Before != nil {
|
|
||||||
return c.startApp(ctx)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !c.HideHelp && (HelpFlag != BoolFlag{}) {
|
|
||||||
// append help to flags
|
|
||||||
c.Flags = append(
|
|
||||||
c.Flags,
|
|
||||||
HelpFlag,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
if ctx.App.EnableBashCompletion {
|
|
||||||
c.Flags = append(c.Flags, BashCompletionFlag)
|
|
||||||
}
|
|
||||||
|
|
||||||
set := flagSet(c.Name, c.Flags)
|
|
||||||
set.SetOutput(ioutil.Discard)
|
|
||||||
|
|
||||||
firstFlagIndex := -1
|
|
||||||
terminatorIndex := -1
|
|
||||||
for index, arg := range ctx.Args() {
|
|
||||||
if arg == "--" {
|
|
||||||
terminatorIndex = index
|
|
||||||
break
|
|
||||||
} else if strings.HasPrefix(arg, "-") && firstFlagIndex == -1 {
|
|
||||||
firstFlagIndex = index
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var err error
|
|
||||||
if firstFlagIndex > -1 && !c.SkipFlagParsing {
|
|
||||||
args := ctx.Args()
|
|
||||||
regularArgs := make([]string, len(args[1:firstFlagIndex]))
|
|
||||||
copy(regularArgs, args[1:firstFlagIndex])
|
|
||||||
|
|
||||||
var flagArgs []string
|
|
||||||
if terminatorIndex > -1 {
|
|
||||||
flagArgs = args[firstFlagIndex:terminatorIndex]
|
|
||||||
regularArgs = append(regularArgs, args[terminatorIndex:]...)
|
|
||||||
} else {
|
|
||||||
flagArgs = args[firstFlagIndex:]
|
|
||||||
}
|
|
||||||
|
|
||||||
err = set.Parse(append(flagArgs, regularArgs...))
|
|
||||||
} else {
|
|
||||||
err = set.Parse(ctx.Args().Tail())
|
|
||||||
}
|
|
||||||
|
|
||||||
if err != nil {
|
|
||||||
fmt.Fprint(ctx.App.Writer, "Incorrect Usage.\n\n")
|
|
||||||
ShowCommandHelp(ctx, c.Name)
|
|
||||||
fmt.Fprintln(ctx.App.Writer)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
nerr := normalizeFlags(c.Flags, set)
|
|
||||||
if nerr != nil {
|
|
||||||
fmt.Fprintln(ctx.App.Writer, nerr)
|
|
||||||
fmt.Fprintln(ctx.App.Writer)
|
|
||||||
ShowCommandHelp(ctx, c.Name)
|
|
||||||
fmt.Fprintln(ctx.App.Writer)
|
|
||||||
return nerr
|
|
||||||
}
|
|
||||||
context := NewContext(ctx.App, set, ctx.globalSet)
|
|
||||||
|
|
||||||
if checkCommandCompletions(context, c.Name) {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if checkCommandHelp(context, c.Name) {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
context.Command = c
|
|
||||||
c.Action(context)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns true if Command.Name or Command.ShortName matches given name
|
|
||||||
func (c Command) HasName(name string) bool {
|
|
||||||
return c.Name == name || c.ShortName == name
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c Command) startApp(ctx *Context) error {
|
|
||||||
app := NewApp()
|
|
||||||
|
|
||||||
// set the name and usage
|
|
||||||
app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
|
|
||||||
if c.Description != "" {
|
|
||||||
app.Usage = c.Description
|
|
||||||
} else {
|
|
||||||
app.Usage = c.Usage
|
|
||||||
}
|
|
||||||
|
|
||||||
// set CommandNotFound
|
|
||||||
app.CommandNotFound = ctx.App.CommandNotFound
|
|
||||||
|
|
||||||
// set the flags and commands
|
|
||||||
app.Commands = c.Subcommands
|
|
||||||
app.Flags = c.Flags
|
|
||||||
app.HideHelp = c.HideHelp
|
|
||||||
|
|
||||||
// bash completion
|
|
||||||
app.EnableBashCompletion = ctx.App.EnableBashCompletion
|
|
||||||
if c.BashComplete != nil {
|
|
||||||
app.BashComplete = c.BashComplete
|
|
||||||
}
|
|
||||||
|
|
||||||
// set the actions
|
|
||||||
app.Before = c.Before
|
|
||||||
if c.Action != nil {
|
|
||||||
app.Action = c.Action
|
|
||||||
} else {
|
|
||||||
app.Action = helpSubcommand.Action
|
|
||||||
}
|
|
||||||
|
|
||||||
return app.RunAsSubcommand(ctx)
|
|
||||||
}
|
|
||||||
|
|
@ -1,49 +0,0 @@
|
||||||
package cli_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"flag"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/codegangsta/cli"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestCommandDoNotIgnoreFlags(t *testing.T) {
|
|
||||||
app := cli.NewApp()
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
test := []string{"blah", "blah", "-break"}
|
|
||||||
set.Parse(test)
|
|
||||||
|
|
||||||
c := cli.NewContext(app, set, set)
|
|
||||||
|
|
||||||
command := cli.Command{
|
|
||||||
Name: "test-cmd",
|
|
||||||
ShortName: "tc",
|
|
||||||
Usage: "this is for testing",
|
|
||||||
Description: "testing",
|
|
||||||
Action: func(_ *cli.Context) {},
|
|
||||||
}
|
|
||||||
err := command.Run(c)
|
|
||||||
|
|
||||||
expect(t, err.Error(), "flag provided but not defined: -break")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCommandIgnoreFlags(t *testing.T) {
|
|
||||||
app := cli.NewApp()
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
test := []string{"blah", "blah"}
|
|
||||||
set.Parse(test)
|
|
||||||
|
|
||||||
c := cli.NewContext(app, set, set)
|
|
||||||
|
|
||||||
command := cli.Command{
|
|
||||||
Name: "test-cmd",
|
|
||||||
ShortName: "tc",
|
|
||||||
Usage: "this is for testing",
|
|
||||||
Description: "testing",
|
|
||||||
Action: func(_ *cli.Context) {},
|
|
||||||
SkipFlagParsing: true,
|
|
||||||
}
|
|
||||||
err := command.Run(c)
|
|
||||||
|
|
||||||
expect(t, err, nil)
|
|
||||||
}
|
|
||||||
|
|
@ -1,339 +0,0 @@
|
||||||
package cli
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"flag"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Context is a type that is passed through to
|
|
||||||
// each Handler action in a cli application. Context
|
|
||||||
// can be used to retrieve context-specific Args and
|
|
||||||
// parsed command-line options.
|
|
||||||
type Context struct {
|
|
||||||
App *App
|
|
||||||
Command Command
|
|
||||||
flagSet *flag.FlagSet
|
|
||||||
globalSet *flag.FlagSet
|
|
||||||
setFlags map[string]bool
|
|
||||||
globalSetFlags map[string]bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// Creates a new context. For use in when invoking an App or Command action.
|
|
||||||
func NewContext(app *App, set *flag.FlagSet, globalSet *flag.FlagSet) *Context {
|
|
||||||
return &Context{App: app, flagSet: set, globalSet: globalSet}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local int flag, returns 0 if no int flag exists
|
|
||||||
func (c *Context) Int(name string) int {
|
|
||||||
return lookupInt(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
|
|
||||||
func (c *Context) Duration(name string) time.Duration {
|
|
||||||
return lookupDuration(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
|
|
||||||
func (c *Context) Float64(name string) float64 {
|
|
||||||
return lookupFloat64(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local bool flag, returns false if no bool flag exists
|
|
||||||
func (c *Context) Bool(name string) bool {
|
|
||||||
return lookupBool(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local boolT flag, returns false if no bool flag exists
|
|
||||||
func (c *Context) BoolT(name string) bool {
|
|
||||||
return lookupBoolT(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local string flag, returns "" if no string flag exists
|
|
||||||
func (c *Context) String(name string) string {
|
|
||||||
return lookupString(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local string slice flag, returns nil if no string slice flag exists
|
|
||||||
func (c *Context) StringSlice(name string) []string {
|
|
||||||
return lookupStringSlice(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local int slice flag, returns nil if no int slice flag exists
|
|
||||||
func (c *Context) IntSlice(name string) []int {
|
|
||||||
return lookupIntSlice(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a local generic flag, returns nil if no generic flag exists
|
|
||||||
func (c *Context) Generic(name string) interface{} {
|
|
||||||
return lookupGeneric(name, c.flagSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a global int flag, returns 0 if no int flag exists
|
|
||||||
func (c *Context) GlobalInt(name string) int {
|
|
||||||
return lookupInt(name, c.globalSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
|
|
||||||
func (c *Context) GlobalDuration(name string) time.Duration {
|
|
||||||
return lookupDuration(name, c.globalSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a global bool flag, returns false if no bool flag exists
|
|
||||||
func (c *Context) GlobalBool(name string) bool {
|
|
||||||
return lookupBool(name, c.globalSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a global string flag, returns "" if no string flag exists
|
|
||||||
func (c *Context) GlobalString(name string) string {
|
|
||||||
return lookupString(name, c.globalSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a global string slice flag, returns nil if no string slice flag exists
|
|
||||||
func (c *Context) GlobalStringSlice(name string) []string {
|
|
||||||
return lookupStringSlice(name, c.globalSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a global int slice flag, returns nil if no int slice flag exists
|
|
||||||
func (c *Context) GlobalIntSlice(name string) []int {
|
|
||||||
return lookupIntSlice(name, c.globalSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks up the value of a global generic flag, returns nil if no generic flag exists
|
|
||||||
func (c *Context) GlobalGeneric(name string) interface{} {
|
|
||||||
return lookupGeneric(name, c.globalSet)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determines if the flag was actually set
|
|
||||||
func (c *Context) IsSet(name string) bool {
|
|
||||||
if c.setFlags == nil {
|
|
||||||
c.setFlags = make(map[string]bool)
|
|
||||||
c.flagSet.Visit(func(f *flag.Flag) {
|
|
||||||
c.setFlags[f.Name] = true
|
|
||||||
})
|
|
||||||
}
|
|
||||||
return c.setFlags[name] == true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determines if the global flag was actually set
|
|
||||||
func (c *Context) GlobalIsSet(name string) bool {
|
|
||||||
if c.globalSetFlags == nil {
|
|
||||||
c.globalSetFlags = make(map[string]bool)
|
|
||||||
c.globalSet.Visit(func(f *flag.Flag) {
|
|
||||||
c.globalSetFlags[f.Name] = true
|
|
||||||
})
|
|
||||||
}
|
|
||||||
return c.globalSetFlags[name] == true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns a slice of flag names used in this context.
|
|
||||||
func (c *Context) FlagNames() (names []string) {
|
|
||||||
for _, flag := range c.Command.Flags {
|
|
||||||
name := strings.Split(flag.getName(), ",")[0]
|
|
||||||
if name == "help" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
names = append(names, name)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns a slice of global flag names used by the app.
|
|
||||||
func (c *Context) GlobalFlagNames() (names []string) {
|
|
||||||
for _, flag := range c.App.Flags {
|
|
||||||
name := strings.Split(flag.getName(), ",")[0]
|
|
||||||
if name == "help" || name == "version" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
names = append(names, name)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
type Args []string
|
|
||||||
|
|
||||||
// Returns the command line arguments associated with the context.
|
|
||||||
func (c *Context) Args() Args {
|
|
||||||
args := Args(c.flagSet.Args())
|
|
||||||
return args
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns the nth argument, or else a blank string
|
|
||||||
func (a Args) Get(n int) string {
|
|
||||||
if len(a) > n {
|
|
||||||
return a[n]
|
|
||||||
}
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns the first argument, or else a blank string
|
|
||||||
func (a Args) First() string {
|
|
||||||
return a.Get(0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return the rest of the arguments (not the first one)
|
|
||||||
// or else an empty string slice
|
|
||||||
func (a Args) Tail() []string {
|
|
||||||
if len(a) >= 2 {
|
|
||||||
return []string(a)[1:]
|
|
||||||
}
|
|
||||||
return []string{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Checks if there are any arguments present
|
|
||||||
func (a Args) Present() bool {
|
|
||||||
return len(a) != 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Swaps arguments at the given indexes
|
|
||||||
func (a Args) Swap(from, to int) error {
|
|
||||||
if from >= len(a) || to >= len(a) {
|
|
||||||
return errors.New("index out of range")
|
|
||||||
}
|
|
||||||
a[from], a[to] = a[to], a[from]
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupInt(name string, set *flag.FlagSet) int {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
val, err := strconv.Atoi(f.Value.String())
|
|
||||||
if err != nil {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
return val
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupDuration(name string, set *flag.FlagSet) time.Duration {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
val, err := time.ParseDuration(f.Value.String())
|
|
||||||
if err == nil {
|
|
||||||
return val
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupFloat64(name string, set *flag.FlagSet) float64 {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
val, err := strconv.ParseFloat(f.Value.String(), 64)
|
|
||||||
if err != nil {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
return val
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupString(name string, set *flag.FlagSet) string {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
return f.Value.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupStringSlice(name string, set *flag.FlagSet) []string {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
return (f.Value.(*StringSlice)).Value()
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupIntSlice(name string, set *flag.FlagSet) []int {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
return (f.Value.(*IntSlice)).Value()
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupGeneric(name string, set *flag.FlagSet) interface{} {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
return f.Value
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupBool(name string, set *flag.FlagSet) bool {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
val, err := strconv.ParseBool(f.Value.String())
|
|
||||||
if err != nil {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
return val
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupBoolT(name string, set *flag.FlagSet) bool {
|
|
||||||
f := set.Lookup(name)
|
|
||||||
if f != nil {
|
|
||||||
val, err := strconv.ParseBool(f.Value.String())
|
|
||||||
if err != nil {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return val
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
|
|
||||||
switch ff.Value.(type) {
|
|
||||||
case *StringSlice:
|
|
||||||
default:
|
|
||||||
set.Set(name, ff.Value.String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
|
|
||||||
visited := make(map[string]bool)
|
|
||||||
set.Visit(func(f *flag.Flag) {
|
|
||||||
visited[f.Name] = true
|
|
||||||
})
|
|
||||||
for _, f := range flags {
|
|
||||||
parts := strings.Split(f.getName(), ",")
|
|
||||||
if len(parts) == 1 {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
var ff *flag.Flag
|
|
||||||
for _, name := range parts {
|
|
||||||
name = strings.Trim(name, " ")
|
|
||||||
if visited[name] {
|
|
||||||
if ff != nil {
|
|
||||||
return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
|
|
||||||
}
|
|
||||||
ff = set.Lookup(name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if ff == nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
for _, name := range parts {
|
|
||||||
name = strings.Trim(name, " ")
|
|
||||||
if !visited[name] {
|
|
||||||
copyFlag(name, ff, set)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,99 +0,0 @@
|
||||||
package cli_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"flag"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/codegangsta/cli"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestNewContext(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.Int("myflag", 12, "doc")
|
|
||||||
globalSet := flag.NewFlagSet("test", 0)
|
|
||||||
globalSet.Int("myflag", 42, "doc")
|
|
||||||
command := cli.Command{Name: "mycommand"}
|
|
||||||
c := cli.NewContext(nil, set, globalSet)
|
|
||||||
c.Command = command
|
|
||||||
expect(t, c.Int("myflag"), 12)
|
|
||||||
expect(t, c.GlobalInt("myflag"), 42)
|
|
||||||
expect(t, c.Command.Name, "mycommand")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestContext_Int(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.Int("myflag", 12, "doc")
|
|
||||||
c := cli.NewContext(nil, set, set)
|
|
||||||
expect(t, c.Int("myflag"), 12)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestContext_Duration(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.Duration("myflag", time.Duration(12*time.Second), "doc")
|
|
||||||
c := cli.NewContext(nil, set, set)
|
|
||||||
expect(t, c.Duration("myflag"), time.Duration(12*time.Second))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestContext_String(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.String("myflag", "hello world", "doc")
|
|
||||||
c := cli.NewContext(nil, set, set)
|
|
||||||
expect(t, c.String("myflag"), "hello world")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestContext_Bool(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.Bool("myflag", false, "doc")
|
|
||||||
c := cli.NewContext(nil, set, set)
|
|
||||||
expect(t, c.Bool("myflag"), false)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestContext_BoolT(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.Bool("myflag", true, "doc")
|
|
||||||
c := cli.NewContext(nil, set, set)
|
|
||||||
expect(t, c.BoolT("myflag"), true)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestContext_Args(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.Bool("myflag", false, "doc")
|
|
||||||
c := cli.NewContext(nil, set, set)
|
|
||||||
set.Parse([]string{"--myflag", "bat", "baz"})
|
|
||||||
expect(t, len(c.Args()), 2)
|
|
||||||
expect(t, c.Bool("myflag"), true)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestContext_IsSet(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.Bool("myflag", false, "doc")
|
|
||||||
set.String("otherflag", "hello world", "doc")
|
|
||||||
globalSet := flag.NewFlagSet("test", 0)
|
|
||||||
globalSet.Bool("myflagGlobal", true, "doc")
|
|
||||||
c := cli.NewContext(nil, set, globalSet)
|
|
||||||
set.Parse([]string{"--myflag", "bat", "baz"})
|
|
||||||
globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
|
|
||||||
expect(t, c.IsSet("myflag"), true)
|
|
||||||
expect(t, c.IsSet("otherflag"), false)
|
|
||||||
expect(t, c.IsSet("bogusflag"), false)
|
|
||||||
expect(t, c.IsSet("myflagGlobal"), false)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestContext_GlobalIsSet(t *testing.T) {
|
|
||||||
set := flag.NewFlagSet("test", 0)
|
|
||||||
set.Bool("myflag", false, "doc")
|
|
||||||
set.String("otherflag", "hello world", "doc")
|
|
||||||
globalSet := flag.NewFlagSet("test", 0)
|
|
||||||
globalSet.Bool("myflagGlobal", true, "doc")
|
|
||||||
globalSet.Bool("myflagGlobalUnset", true, "doc")
|
|
||||||
c := cli.NewContext(nil, set, globalSet)
|
|
||||||
set.Parse([]string{"--myflag", "bat", "baz"})
|
|
||||||
globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
|
|
||||||
expect(t, c.GlobalIsSet("myflag"), false)
|
|
||||||
expect(t, c.GlobalIsSet("otherflag"), false)
|
|
||||||
expect(t, c.GlobalIsSet("bogusflag"), false)
|
|
||||||
expect(t, c.GlobalIsSet("myflagGlobal"), true)
|
|
||||||
expect(t, c.GlobalIsSet("myflagGlobalUnset"), false)
|
|
||||||
expect(t, c.GlobalIsSet("bogusGlobal"), false)
|
|
||||||
}
|
|
||||||
|
|
@ -1,454 +0,0 @@
|
||||||
package cli
|
|
||||||
|
|
||||||
import (
|
|
||||||
"flag"
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// This flag enables bash-completion for all commands and subcommands
|
|
||||||
var BashCompletionFlag = BoolFlag{
|
|
||||||
Name: "generate-bash-completion",
|
|
||||||
}
|
|
||||||
|
|
||||||
// This flag prints the version for the application
|
|
||||||
var VersionFlag = BoolFlag{
|
|
||||||
Name: "version, v",
|
|
||||||
Usage: "print the version",
|
|
||||||
}
|
|
||||||
|
|
||||||
// This flag prints the help for all commands and subcommands
|
|
||||||
// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
|
|
||||||
// unless HideHelp is set to true)
|
|
||||||
var HelpFlag = BoolFlag{
|
|
||||||
Name: "help, h",
|
|
||||||
Usage: "show help",
|
|
||||||
}
|
|
||||||
|
|
||||||
// Flag is a common interface related to parsing flags in cli.
|
|
||||||
// For more advanced flag parsing techniques, it is recomended that
|
|
||||||
// this interface be implemented.
|
|
||||||
type Flag interface {
|
|
||||||
fmt.Stringer
|
|
||||||
// Apply Flag settings to the given flag set
|
|
||||||
Apply(*flag.FlagSet)
|
|
||||||
getName() string
|
|
||||||
}
|
|
||||||
|
|
||||||
func flagSet(name string, flags []Flag) *flag.FlagSet {
|
|
||||||
set := flag.NewFlagSet(name, flag.ContinueOnError)
|
|
||||||
|
|
||||||
for _, f := range flags {
|
|
||||||
f.Apply(set)
|
|
||||||
}
|
|
||||||
return set
|
|
||||||
}
|
|
||||||
|
|
||||||
func eachName(longName string, fn func(string)) {
|
|
||||||
parts := strings.Split(longName, ",")
|
|
||||||
for _, name := range parts {
|
|
||||||
name = strings.Trim(name, " ")
|
|
||||||
fn(name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Generic is a generic parseable type identified by a specific flag
|
|
||||||
type Generic interface {
|
|
||||||
Set(value string) error
|
|
||||||
String() string
|
|
||||||
}
|
|
||||||
|
|
||||||
// GenericFlag is the flag type for types implementing Generic
|
|
||||||
type GenericFlag struct {
|
|
||||||
Name string
|
|
||||||
Value Generic
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
// String returns the string representation of the generic flag to display the
|
|
||||||
// help text to the user (uses the String() method of the generic flag to show
|
|
||||||
// the value)
|
|
||||||
func (f GenericFlag) String() string {
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf("%s%s \"%v\"\t%v", prefixFor(f.Name), f.Name, f.Value, f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Apply takes the flagset and calls Set on the generic flag with the value
|
|
||||||
// provided by the user for parsing by the flag
|
|
||||||
func (f GenericFlag) Apply(set *flag.FlagSet) {
|
|
||||||
val := f.Value
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
val.Set(envVal)
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.Var(f.Value, name, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f GenericFlag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type StringSlice []string
|
|
||||||
|
|
||||||
func (f *StringSlice) Set(value string) error {
|
|
||||||
*f = append(*f, value)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *StringSlice) String() string {
|
|
||||||
return fmt.Sprintf("%s", *f)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *StringSlice) Value() []string {
|
|
||||||
return *f
|
|
||||||
}
|
|
||||||
|
|
||||||
type StringSliceFlag struct {
|
|
||||||
Name string
|
|
||||||
Value *StringSlice
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f StringSliceFlag) String() string {
|
|
||||||
firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
|
|
||||||
pref := prefixFor(firstName)
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f StringSliceFlag) Apply(set *flag.FlagSet) {
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
newVal := &StringSlice{}
|
|
||||||
for _, s := range strings.Split(envVal, ",") {
|
|
||||||
s = strings.TrimSpace(s)
|
|
||||||
newVal.Set(s)
|
|
||||||
}
|
|
||||||
f.Value = newVal
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.Var(f.Value, name, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f StringSliceFlag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type IntSlice []int
|
|
||||||
|
|
||||||
func (f *IntSlice) Set(value string) error {
|
|
||||||
|
|
||||||
tmp, err := strconv.Atoi(value)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
} else {
|
|
||||||
*f = append(*f, tmp)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *IntSlice) String() string {
|
|
||||||
return fmt.Sprintf("%d", *f)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *IntSlice) Value() []int {
|
|
||||||
return *f
|
|
||||||
}
|
|
||||||
|
|
||||||
type IntSliceFlag struct {
|
|
||||||
Name string
|
|
||||||
Value *IntSlice
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f IntSliceFlag) String() string {
|
|
||||||
firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
|
|
||||||
pref := prefixFor(firstName)
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f IntSliceFlag) Apply(set *flag.FlagSet) {
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
newVal := &IntSlice{}
|
|
||||||
for _, s := range strings.Split(envVal, ",") {
|
|
||||||
s = strings.TrimSpace(s)
|
|
||||||
err := newVal.Set(s)
|
|
||||||
if err != nil {
|
|
||||||
fmt.Fprintf(os.Stderr, err.Error())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
f.Value = newVal
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.Var(f.Value, name, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f IntSliceFlag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type BoolFlag struct {
|
|
||||||
Name string
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f BoolFlag) String() string {
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f BoolFlag) Apply(set *flag.FlagSet) {
|
|
||||||
val := false
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
envValBool, err := strconv.ParseBool(envVal)
|
|
||||||
if err == nil {
|
|
||||||
val = envValBool
|
|
||||||
}
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.Bool(name, val, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f BoolFlag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type BoolTFlag struct {
|
|
||||||
Name string
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f BoolTFlag) String() string {
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f BoolTFlag) Apply(set *flag.FlagSet) {
|
|
||||||
val := true
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
envValBool, err := strconv.ParseBool(envVal)
|
|
||||||
if err == nil {
|
|
||||||
val = envValBool
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.Bool(name, val, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f BoolTFlag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type StringFlag struct {
|
|
||||||
Name string
|
|
||||||
Value string
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f StringFlag) String() string {
|
|
||||||
var fmtString string
|
|
||||||
fmtString = "%s %v\t%v"
|
|
||||||
|
|
||||||
if len(f.Value) > 0 {
|
|
||||||
fmtString = "%s \"%v\"\t%v"
|
|
||||||
} else {
|
|
||||||
fmtString = "%s %v\t%v"
|
|
||||||
}
|
|
||||||
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f StringFlag) Apply(set *flag.FlagSet) {
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
f.Value = envVal
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.String(name, f.Value, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f StringFlag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type IntFlag struct {
|
|
||||||
Name string
|
|
||||||
Value int
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f IntFlag) String() string {
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f IntFlag) Apply(set *flag.FlagSet) {
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
envValInt, err := strconv.ParseInt(envVal, 0, 64)
|
|
||||||
if err == nil {
|
|
||||||
f.Value = int(envValInt)
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.Int(name, f.Value, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f IntFlag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type DurationFlag struct {
|
|
||||||
Name string
|
|
||||||
Value time.Duration
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f DurationFlag) String() string {
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f DurationFlag) Apply(set *flag.FlagSet) {
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
envValDuration, err := time.ParseDuration(envVal)
|
|
||||||
if err == nil {
|
|
||||||
f.Value = envValDuration
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.Duration(name, f.Value, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f DurationFlag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type Float64Flag struct {
|
|
||||||
Name string
|
|
||||||
Value float64
|
|
||||||
Usage string
|
|
||||||
EnvVar string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f Float64Flag) String() string {
|
|
||||||
return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f Float64Flag) Apply(set *flag.FlagSet) {
|
|
||||||
if f.EnvVar != "" {
|
|
||||||
for _, envVar := range strings.Split(f.EnvVar, ",") {
|
|
||||||
envVar = strings.TrimSpace(envVar)
|
|
||||||
if envVal := os.Getenv(envVar); envVal != "" {
|
|
||||||
envValFloat, err := strconv.ParseFloat(envVal, 10)
|
|
||||||
if err == nil {
|
|
||||||
f.Value = float64(envValFloat)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eachName(f.Name, func(name string) {
|
|
||||||
set.Float64(name, f.Value, f.Usage)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f Float64Flag) getName() string {
|
|
||||||
return f.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
func prefixFor(name string) (prefix string) {
|
|
||||||
if len(name) == 1 {
|
|
||||||
prefix = "-"
|
|
||||||
} else {
|
|
||||||
prefix = "--"
|
|
||||||
}
|
|
||||||
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func prefixedNames(fullName string) (prefixed string) {
|
|
||||||
parts := strings.Split(fullName, ",")
|
|
||||||
for i, name := range parts {
|
|
||||||
name = strings.Trim(name, " ")
|
|
||||||
prefixed += prefixFor(name) + name
|
|
||||||
if i < len(parts)-1 {
|
|
||||||
prefixed += ", "
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func withEnvHint(envVar, str string) string {
|
|
||||||
envText := ""
|
|
||||||
if envVar != "" {
|
|
||||||
envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
|
|
||||||
}
|
|
||||||
return str + envText
|
|
||||||
}
|
|
||||||
|
|
@ -1,742 +0,0 @@
|
||||||
package cli_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"reflect"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/codegangsta/cli"
|
|
||||||
)
|
|
||||||
|
|
||||||
var boolFlagTests = []struct {
|
|
||||||
name string
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{"help", "--help\t"},
|
|
||||||
{"h", "-h\t"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBoolFlagHelpOutput(t *testing.T) {
|
|
||||||
|
|
||||||
for _, test := range boolFlagTests {
|
|
||||||
flag := cli.BoolFlag{Name: test.name}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if output != test.expected {
|
|
||||||
t.Errorf("%s does not match %s", output, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var stringFlagTests = []struct {
|
|
||||||
name string
|
|
||||||
value string
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{"help", "", "--help \t"},
|
|
||||||
{"h", "", "-h \t"},
|
|
||||||
{"h", "", "-h \t"},
|
|
||||||
{"test", "Something", "--test \"Something\"\t"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStringFlagHelpOutput(t *testing.T) {
|
|
||||||
|
|
||||||
for _, test := range stringFlagTests {
|
|
||||||
flag := cli.StringFlag{Name: test.name, Value: test.value}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if output != test.expected {
|
|
||||||
t.Errorf("%s does not match %s", output, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_FOO", "derp")
|
|
||||||
for _, test := range stringFlagTests {
|
|
||||||
flag := cli.StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if !strings.HasSuffix(output, " [$APP_FOO]") {
|
|
||||||
t.Errorf("%s does not end with [$APP_FOO]", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var stringSliceFlagTests = []struct {
|
|
||||||
name string
|
|
||||||
value *cli.StringSlice
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{"help", func() *cli.StringSlice {
|
|
||||||
s := &cli.StringSlice{}
|
|
||||||
s.Set("")
|
|
||||||
return s
|
|
||||||
}(), "--help [--help option --help option]\t"},
|
|
||||||
{"h", func() *cli.StringSlice {
|
|
||||||
s := &cli.StringSlice{}
|
|
||||||
s.Set("")
|
|
||||||
return s
|
|
||||||
}(), "-h [-h option -h option]\t"},
|
|
||||||
{"h", func() *cli.StringSlice {
|
|
||||||
s := &cli.StringSlice{}
|
|
||||||
s.Set("")
|
|
||||||
return s
|
|
||||||
}(), "-h [-h option -h option]\t"},
|
|
||||||
{"test", func() *cli.StringSlice {
|
|
||||||
s := &cli.StringSlice{}
|
|
||||||
s.Set("Something")
|
|
||||||
return s
|
|
||||||
}(), "--test [--test option --test option]\t"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStringSliceFlagHelpOutput(t *testing.T) {
|
|
||||||
|
|
||||||
for _, test := range stringSliceFlagTests {
|
|
||||||
flag := cli.StringSliceFlag{Name: test.name, Value: test.value}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if output != test.expected {
|
|
||||||
t.Errorf("%q does not match %q", output, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_QWWX", "11,4")
|
|
||||||
for _, test := range stringSliceFlagTests {
|
|
||||||
flag := cli.StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if !strings.HasSuffix(output, " [$APP_QWWX]") {
|
|
||||||
t.Errorf("%q does not end with [$APP_QWWX]", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var intFlagTests = []struct {
|
|
||||||
name string
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{"help", "--help \"0\"\t"},
|
|
||||||
{"h", "-h \"0\"\t"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIntFlagHelpOutput(t *testing.T) {
|
|
||||||
|
|
||||||
for _, test := range intFlagTests {
|
|
||||||
flag := cli.IntFlag{Name: test.name}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if output != test.expected {
|
|
||||||
t.Errorf("%s does not match %s", output, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIntFlagWithEnvVarHelpOutput(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_BAR", "2")
|
|
||||||
for _, test := range intFlagTests {
|
|
||||||
flag := cli.IntFlag{Name: test.name, EnvVar: "APP_BAR"}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if !strings.HasSuffix(output, " [$APP_BAR]") {
|
|
||||||
t.Errorf("%s does not end with [$APP_BAR]", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var durationFlagTests = []struct {
|
|
||||||
name string
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{"help", "--help \"0\"\t"},
|
|
||||||
{"h", "-h \"0\"\t"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestDurationFlagHelpOutput(t *testing.T) {
|
|
||||||
|
|
||||||
for _, test := range durationFlagTests {
|
|
||||||
flag := cli.DurationFlag{Name: test.name}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if output != test.expected {
|
|
||||||
t.Errorf("%s does not match %s", output, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_BAR", "2h3m6s")
|
|
||||||
for _, test := range durationFlagTests {
|
|
||||||
flag := cli.DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if !strings.HasSuffix(output, " [$APP_BAR]") {
|
|
||||||
t.Errorf("%s does not end with [$APP_BAR]", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var intSliceFlagTests = []struct {
|
|
||||||
name string
|
|
||||||
value *cli.IntSlice
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{"help", &cli.IntSlice{}, "--help [--help option --help option]\t"},
|
|
||||||
{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"},
|
|
||||||
{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"},
|
|
||||||
{"test", func() *cli.IntSlice {
|
|
||||||
i := &cli.IntSlice{}
|
|
||||||
i.Set("9")
|
|
||||||
return i
|
|
||||||
}(), "--test [--test option --test option]\t"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIntSliceFlagHelpOutput(t *testing.T) {
|
|
||||||
|
|
||||||
for _, test := range intSliceFlagTests {
|
|
||||||
flag := cli.IntSliceFlag{Name: test.name, Value: test.value}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if output != test.expected {
|
|
||||||
t.Errorf("%q does not match %q", output, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_SMURF", "42,3")
|
|
||||||
for _, test := range intSliceFlagTests {
|
|
||||||
flag := cli.IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if !strings.HasSuffix(output, " [$APP_SMURF]") {
|
|
||||||
t.Errorf("%q does not end with [$APP_SMURF]", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var float64FlagTests = []struct {
|
|
||||||
name string
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{"help", "--help \"0\"\t"},
|
|
||||||
{"h", "-h \"0\"\t"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestFloat64FlagHelpOutput(t *testing.T) {
|
|
||||||
|
|
||||||
for _, test := range float64FlagTests {
|
|
||||||
flag := cli.Float64Flag{Name: test.name}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if output != test.expected {
|
|
||||||
t.Errorf("%s does not match %s", output, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_BAZ", "99.4")
|
|
||||||
for _, test := range float64FlagTests {
|
|
||||||
flag := cli.Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if !strings.HasSuffix(output, " [$APP_BAZ]") {
|
|
||||||
t.Errorf("%s does not end with [$APP_BAZ]", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var genericFlagTests = []struct {
|
|
||||||
name string
|
|
||||||
value cli.Generic
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{"test", &Parser{"abc", "def"}, "--test \"abc,def\"\ttest flag"},
|
|
||||||
{"t", &Parser{"abc", "def"}, "-t \"abc,def\"\ttest flag"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGenericFlagHelpOutput(t *testing.T) {
|
|
||||||
|
|
||||||
for _, test := range genericFlagTests {
|
|
||||||
flag := cli.GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if output != test.expected {
|
|
||||||
t.Errorf("%q does not match %q", output, test.expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_ZAP", "3")
|
|
||||||
for _, test := range genericFlagTests {
|
|
||||||
flag := cli.GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
|
|
||||||
output := flag.String()
|
|
||||||
|
|
||||||
if !strings.HasSuffix(output, " [$APP_ZAP]") {
|
|
||||||
t.Errorf("%s does not end with [$APP_ZAP]", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiString(t *testing.T) {
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{Name: "serve, s"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.String("serve") != "10" {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.String("s") != "10" {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run", "-s", "10"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiStringFromEnv(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_COUNT", "20")
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.String("count") != "20" {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.String("c") != "20" {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiStringFromEnvCascade(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_COUNT", "20")
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.String("count") != "20" {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.String("c") != "20" {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiStringSlice(t *testing.T) {
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringSliceFlag{Name: "serve, s", Value: &cli.StringSlice{}},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(ctx.StringSlice("s"), []string{"10", "20"}) {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run", "-s", "10", "-s", "20"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiStringSliceFromEnv(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_INTERVALS", "20,30,40")
|
|
||||||
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "APP_INTERVALS"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_INTERVALS", "20,30,40")
|
|
||||||
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiInt(t *testing.T) {
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.IntFlag{Name: "serve, s"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Int("serve") != 10 {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.Int("s") != 10 {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run", "-s", "10"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiIntFromEnv(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_TIMEOUT_SECONDS", "10")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Int("timeout") != 10 {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.Int("t") != 10 {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiIntFromEnvCascade(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_TIMEOUT_SECONDS", "10")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Int("timeout") != 10 {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.Int("t") != 10 {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiIntSlice(t *testing.T) {
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.IntSliceFlag{Name: "serve, s", Value: &cli.IntSlice{}},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(ctx.IntSlice("s"), []int{10, 20}) {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run", "-s", "10", "-s", "20"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiIntSliceFromEnv(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_INTERVALS", "20,30,40")
|
|
||||||
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "APP_INTERVALS"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_INTERVALS", "20,30,40")
|
|
||||||
|
|
||||||
(&cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}).Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiFloat64(t *testing.T) {
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.Float64Flag{Name: "serve, s"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Float64("serve") != 10.2 {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.Float64("s") != 10.2 {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run", "-s", "10.2"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiFloat64FromEnv(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Float64("timeout") != 15.5 {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.Float64("t") != 15.5 {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Float64("timeout") != 15.5 {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.Float64("t") != 15.5 {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiBool(t *testing.T) {
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.BoolFlag{Name: "serve, s"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Bool("serve") != true {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.Bool("s") != true {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run", "--serve"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiBoolFromEnv(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_DEBUG", "1")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Bool("debug") != true {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if ctx.Bool("d") != true {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiBoolFromEnvCascade(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_DEBUG", "1")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.Bool("debug") != true {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if ctx.Bool("d") != true {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiBoolT(t *testing.T) {
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.BoolTFlag{Name: "serve, s"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.BoolT("serve") != true {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if ctx.BoolT("s") != true {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run", "--serve"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiBoolTFromEnv(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_DEBUG", "0")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.BoolT("debug") != false {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if ctx.BoolT("d") != false {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseMultiBoolTFromEnvCascade(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_DEBUG", "0")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if ctx.BoolT("debug") != false {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if ctx.BoolT("d") != false {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
type Parser [2]string
|
|
||||||
|
|
||||||
func (p *Parser) Set(value string) error {
|
|
||||||
parts := strings.Split(value, ",")
|
|
||||||
if len(parts) != 2 {
|
|
||||||
return fmt.Errorf("invalid format")
|
|
||||||
}
|
|
||||||
|
|
||||||
(*p)[0] = parts[0]
|
|
||||||
(*p)[1] = parts[1]
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *Parser) String() string {
|
|
||||||
return fmt.Sprintf("%s,%s", p[0], p[1])
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseGeneric(t *testing.T) {
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.GenericFlag{Name: "serve, s", Value: &Parser{}},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) {
|
|
||||||
t.Errorf("main name not set")
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"10", "20"}) {
|
|
||||||
t.Errorf("short name not set")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run", "-s", "10,20"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseGenericFromEnv(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_SERVE", "20,30")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) {
|
|
||||||
t.Errorf("main name not set from env")
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"20", "30"}) {
|
|
||||||
t.Errorf("short name not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseGenericFromEnvCascade(t *testing.T) {
|
|
||||||
os.Clearenv()
|
|
||||||
os.Setenv("APP_FOO", "99,2000")
|
|
||||||
a := cli.App{
|
|
||||||
Flags: []cli.Flag{
|
|
||||||
cli.GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"},
|
|
||||||
},
|
|
||||||
Action: func(ctx *cli.Context) {
|
|
||||||
if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) {
|
|
||||||
t.Errorf("value not set from env")
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
a.Run([]string{"run"})
|
|
||||||
}
|
|
||||||
|
|
@ -1,211 +0,0 @@
|
||||||
package cli
|
|
||||||
|
|
||||||
import "fmt"
|
|
||||||
|
|
||||||
// The text template for the Default help topic.
|
|
||||||
// cli.go uses text/template to render templates. You can
|
|
||||||
// render custom help text by setting this variable.
|
|
||||||
var AppHelpTemplate = `NAME:
|
|
||||||
{{.Name}} - {{.Usage}}
|
|
||||||
|
|
||||||
USAGE:
|
|
||||||
{{.Name}} {{if .Flags}}[global options] {{end}}command{{if .Flags}} [command options]{{end}} [arguments...]
|
|
||||||
|
|
||||||
VERSION:
|
|
||||||
{{.Version}}{{if or .Author .Email}}
|
|
||||||
|
|
||||||
AUTHOR:{{if .Author}}
|
|
||||||
{{.Author}}{{if .Email}} - <{{.Email}}>{{end}}{{else}}
|
|
||||||
{{.Email}}{{end}}{{end}}
|
|
||||||
|
|
||||||
COMMANDS:
|
|
||||||
{{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
|
|
||||||
{{end}}{{if .Flags}}
|
|
||||||
GLOBAL OPTIONS:
|
|
||||||
{{range .Flags}}{{.}}
|
|
||||||
{{end}}{{end}}
|
|
||||||
`
|
|
||||||
|
|
||||||
// The text template for the command help topic.
|
|
||||||
// cli.go uses text/template to render templates. You can
|
|
||||||
// render custom help text by setting this variable.
|
|
||||||
var CommandHelpTemplate = `NAME:
|
|
||||||
{{.Name}} - {{.Usage}}
|
|
||||||
|
|
||||||
USAGE:
|
|
||||||
command {{.Name}}{{if .Flags}} [command options]{{end}} [arguments...]{{if .Description}}
|
|
||||||
|
|
||||||
DESCRIPTION:
|
|
||||||
{{.Description}}{{end}}{{if .Flags}}
|
|
||||||
|
|
||||||
OPTIONS:
|
|
||||||
{{range .Flags}}{{.}}
|
|
||||||
{{end}}{{ end }}
|
|
||||||
`
|
|
||||||
|
|
||||||
// The text template for the subcommand help topic.
|
|
||||||
// cli.go uses text/template to render templates. You can
|
|
||||||
// render custom help text by setting this variable.
|
|
||||||
var SubcommandHelpTemplate = `NAME:
|
|
||||||
{{.Name}} - {{.Usage}}
|
|
||||||
|
|
||||||
USAGE:
|
|
||||||
{{.Name}} command{{if .Flags}} [command options]{{end}} [arguments...]
|
|
||||||
|
|
||||||
COMMANDS:
|
|
||||||
{{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
|
|
||||||
{{end}}{{if .Flags}}
|
|
||||||
OPTIONS:
|
|
||||||
{{range .Flags}}{{.}}
|
|
||||||
{{end}}{{end}}
|
|
||||||
`
|
|
||||||
|
|
||||||
var helpCommand = Command{
|
|
||||||
Name: "help",
|
|
||||||
ShortName: "h",
|
|
||||||
Usage: "Shows a list of commands or help for one command",
|
|
||||||
Action: func(c *Context) {
|
|
||||||
args := c.Args()
|
|
||||||
if args.Present() {
|
|
||||||
ShowCommandHelp(c, args.First())
|
|
||||||
} else {
|
|
||||||
ShowAppHelp(c)
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
var helpSubcommand = Command{
|
|
||||||
Name: "help",
|
|
||||||
ShortName: "h",
|
|
||||||
Usage: "Shows a list of commands or help for one command",
|
|
||||||
Action: func(c *Context) {
|
|
||||||
args := c.Args()
|
|
||||||
if args.Present() {
|
|
||||||
ShowCommandHelp(c, args.First())
|
|
||||||
} else {
|
|
||||||
ShowSubcommandHelp(c)
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
// Prints help for the App
|
|
||||||
type helpPrinter func(templ string, data interface{})
|
|
||||||
|
|
||||||
var HelpPrinter helpPrinter = nil
|
|
||||||
|
|
||||||
// Prints version for the App
|
|
||||||
var VersionPrinter = printVersion
|
|
||||||
|
|
||||||
func ShowAppHelp(c *Context) {
|
|
||||||
HelpPrinter(AppHelpTemplate, c.App)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Prints the list of subcommands as the default app completion method
|
|
||||||
func DefaultAppComplete(c *Context) {
|
|
||||||
for _, command := range c.App.Commands {
|
|
||||||
fmt.Fprintln(c.App.Writer, command.Name)
|
|
||||||
if command.ShortName != "" {
|
|
||||||
fmt.Fprintln(c.App.Writer, command.ShortName)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Prints help for the given command
|
|
||||||
func ShowCommandHelp(c *Context, command string) {
|
|
||||||
for _, c := range c.App.Commands {
|
|
||||||
if c.HasName(command) {
|
|
||||||
HelpPrinter(CommandHelpTemplate, c)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if c.App.CommandNotFound != nil {
|
|
||||||
c.App.CommandNotFound(c, command)
|
|
||||||
} else {
|
|
||||||
fmt.Fprintf(c.App.Writer, "No help topic for '%v'\n", command)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Prints help for the given subcommand
|
|
||||||
func ShowSubcommandHelp(c *Context) {
|
|
||||||
ShowCommandHelp(c, c.Command.Name)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Prints the version number of the App
|
|
||||||
func ShowVersion(c *Context) {
|
|
||||||
VersionPrinter(c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func printVersion(c *Context) {
|
|
||||||
fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Prints the lists of commands within a given context
|
|
||||||
func ShowCompletions(c *Context) {
|
|
||||||
a := c.App
|
|
||||||
if a != nil && a.BashComplete != nil {
|
|
||||||
a.BashComplete(c)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Prints the custom completions for a given command
|
|
||||||
func ShowCommandCompletions(ctx *Context, command string) {
|
|
||||||
c := ctx.App.Command(command)
|
|
||||||
if c != nil && c.BashComplete != nil {
|
|
||||||
c.BashComplete(ctx)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkVersion(c *Context) bool {
|
|
||||||
if c.GlobalBool("version") {
|
|
||||||
ShowVersion(c)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkHelp(c *Context) bool {
|
|
||||||
if c.GlobalBool("h") || c.GlobalBool("help") {
|
|
||||||
ShowAppHelp(c)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkCommandHelp(c *Context, name string) bool {
|
|
||||||
if c.Bool("h") || c.Bool("help") {
|
|
||||||
ShowCommandHelp(c, name)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkSubcommandHelp(c *Context) bool {
|
|
||||||
if c.GlobalBool("h") || c.GlobalBool("help") {
|
|
||||||
ShowSubcommandHelp(c)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkCompletions(c *Context) bool {
|
|
||||||
if (c.GlobalBool(BashCompletionFlag.Name) || c.Bool(BashCompletionFlag.Name)) && c.App.EnableBashCompletion {
|
|
||||||
ShowCompletions(c)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkCommandCompletions(c *Context, name string) bool {
|
|
||||||
if c.Bool(BashCompletionFlag.Name) && c.App.EnableBashCompletion {
|
|
||||||
ShowCommandCompletions(c, name)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
package cli_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"reflect"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
/* Test Helpers */
|
|
||||||
func expect(t *testing.T, a interface{}, b interface{}) {
|
|
||||||
if a != b {
|
|
||||||
t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func refute(t *testing.T, a interface{}, b interface{}) {
|
|
||||||
if a == b {
|
|
||||||
t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,15 +0,0 @@
|
||||||
package dockerversion
|
|
||||||
|
|
||||||
// FIXME: this should be embedded in the docker/docker.go,
|
|
||||||
// but we can't because distro policy requires us to
|
|
||||||
// package a separate dockerinit binary, and that binary needs
|
|
||||||
// to know its version too.
|
|
||||||
|
|
||||||
var (
|
|
||||||
GITCOMMIT string
|
|
||||||
VERSION string
|
|
||||||
|
|
||||||
IAMSTATIC string // whether or not Docker itself was compiled statically via ./hack/make.sh binary ("true" or not "true")
|
|
||||||
INITSHA1 string // sha1sum of separate static dockerinit, if Docker itself was compiled dynamically via ./hack/make.sh dynbinary
|
|
||||||
INITPATH string // custom location to search for a valid dockerinit binary (available for packagers as a last resort escape hatch)
|
|
||||||
)
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
Solomon Hykes <solomon@docker.com> (@shykes)
|
|
||||||
|
|
@ -1,252 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"os"
|
|
||||||
"sort"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/ioutils"
|
|
||||||
"github.com/docker/docker/utils"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Installer is a standard interface for objects which can "install" themselves
|
|
||||||
// on an engine by registering handlers.
|
|
||||||
// This can be used as an entrypoint for external plugins etc.
|
|
||||||
type Installer interface {
|
|
||||||
Install(*Engine) error
|
|
||||||
}
|
|
||||||
|
|
||||||
type Handler func(*Job) Status
|
|
||||||
|
|
||||||
var globalHandlers map[string]Handler
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
globalHandlers = make(map[string]Handler)
|
|
||||||
}
|
|
||||||
|
|
||||||
func Register(name string, handler Handler) error {
|
|
||||||
_, exists := globalHandlers[name]
|
|
||||||
if exists {
|
|
||||||
return fmt.Errorf("Can't overwrite global handler for command %s", name)
|
|
||||||
}
|
|
||||||
globalHandlers[name] = handler
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func unregister(name string) {
|
|
||||||
delete(globalHandlers, name)
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Engine is the core of Docker.
|
|
||||||
// It acts as a store for *containers*, and allows manipulation of these
|
|
||||||
// containers by executing *jobs*.
|
|
||||||
type Engine struct {
|
|
||||||
handlers map[string]Handler
|
|
||||||
catchall Handler
|
|
||||||
hack Hack // data for temporary hackery (see hack.go)
|
|
||||||
id string
|
|
||||||
Stdout io.Writer
|
|
||||||
Stderr io.Writer
|
|
||||||
Stdin io.Reader
|
|
||||||
Logging bool
|
|
||||||
tasks sync.WaitGroup
|
|
||||||
l sync.RWMutex // lock for shutdown
|
|
||||||
shutdown bool
|
|
||||||
onShutdown []func() // shutdown handlers
|
|
||||||
}
|
|
||||||
|
|
||||||
func (eng *Engine) Register(name string, handler Handler) error {
|
|
||||||
_, exists := eng.handlers[name]
|
|
||||||
if exists {
|
|
||||||
return fmt.Errorf("Can't overwrite handler for command %s", name)
|
|
||||||
}
|
|
||||||
eng.handlers[name] = handler
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (eng *Engine) RegisterCatchall(catchall Handler) {
|
|
||||||
eng.catchall = catchall
|
|
||||||
}
|
|
||||||
|
|
||||||
// New initializes a new engine.
|
|
||||||
func New() *Engine {
|
|
||||||
eng := &Engine{
|
|
||||||
handlers: make(map[string]Handler),
|
|
||||||
id: utils.RandomString(),
|
|
||||||
Stdout: os.Stdout,
|
|
||||||
Stderr: os.Stderr,
|
|
||||||
Stdin: os.Stdin,
|
|
||||||
Logging: true,
|
|
||||||
}
|
|
||||||
eng.Register("commands", func(job *Job) Status {
|
|
||||||
for _, name := range eng.commands() {
|
|
||||||
job.Printf("%s\n", name)
|
|
||||||
}
|
|
||||||
return StatusOK
|
|
||||||
})
|
|
||||||
// Copy existing global handlers
|
|
||||||
for k, v := range globalHandlers {
|
|
||||||
eng.handlers[k] = v
|
|
||||||
}
|
|
||||||
return eng
|
|
||||||
}
|
|
||||||
|
|
||||||
func (eng *Engine) String() string {
|
|
||||||
return fmt.Sprintf("%s", eng.id[:8])
|
|
||||||
}
|
|
||||||
|
|
||||||
// Commands returns a list of all currently registered commands,
|
|
||||||
// sorted alphabetically.
|
|
||||||
func (eng *Engine) commands() []string {
|
|
||||||
names := make([]string, 0, len(eng.handlers))
|
|
||||||
for name := range eng.handlers {
|
|
||||||
names = append(names, name)
|
|
||||||
}
|
|
||||||
sort.Strings(names)
|
|
||||||
return names
|
|
||||||
}
|
|
||||||
|
|
||||||
// Job creates a new job which can later be executed.
|
|
||||||
// This function mimics `Command` from the standard os/exec package.
|
|
||||||
func (eng *Engine) Job(name string, args ...string) *Job {
|
|
||||||
job := &Job{
|
|
||||||
Eng: eng,
|
|
||||||
Name: name,
|
|
||||||
Args: args,
|
|
||||||
Stdin: NewInput(),
|
|
||||||
Stdout: NewOutput(),
|
|
||||||
Stderr: NewOutput(),
|
|
||||||
env: &Env{},
|
|
||||||
closeIO: true,
|
|
||||||
}
|
|
||||||
if eng.Logging {
|
|
||||||
job.Stderr.Add(ioutils.NopWriteCloser(eng.Stderr))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Catchall is shadowed by specific Register.
|
|
||||||
if handler, exists := eng.handlers[name]; exists {
|
|
||||||
job.handler = handler
|
|
||||||
} else if eng.catchall != nil && name != "" {
|
|
||||||
// empty job names are illegal, catchall or not.
|
|
||||||
job.handler = eng.catchall
|
|
||||||
}
|
|
||||||
return job
|
|
||||||
}
|
|
||||||
|
|
||||||
// OnShutdown registers a new callback to be called by Shutdown.
|
|
||||||
// This is typically used by services to perform cleanup.
|
|
||||||
func (eng *Engine) OnShutdown(h func()) {
|
|
||||||
eng.l.Lock()
|
|
||||||
eng.onShutdown = append(eng.onShutdown, h)
|
|
||||||
eng.l.Unlock()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Shutdown permanently shuts down eng as follows:
|
|
||||||
// - It refuses all new jobs, permanently.
|
|
||||||
// - It waits for all active jobs to complete (with no timeout)
|
|
||||||
// - It calls all shutdown handlers concurrently (if any)
|
|
||||||
// - It returns when all handlers complete, or after 15 seconds,
|
|
||||||
// whichever happens first.
|
|
||||||
func (eng *Engine) Shutdown() {
|
|
||||||
eng.l.Lock()
|
|
||||||
if eng.shutdown {
|
|
||||||
eng.l.Unlock()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
eng.shutdown = true
|
|
||||||
eng.l.Unlock()
|
|
||||||
// We don't need to protect the rest with a lock, to allow
|
|
||||||
// for other calls to immediately fail with "shutdown" instead
|
|
||||||
// of hanging for 15 seconds.
|
|
||||||
// This requires all concurrent calls to check for shutdown, otherwise
|
|
||||||
// it might cause a race.
|
|
||||||
|
|
||||||
// Wait for all jobs to complete.
|
|
||||||
// Timeout after 5 seconds.
|
|
||||||
tasksDone := make(chan struct{})
|
|
||||||
go func() {
|
|
||||||
eng.tasks.Wait()
|
|
||||||
close(tasksDone)
|
|
||||||
}()
|
|
||||||
select {
|
|
||||||
case <-time.After(time.Second * 5):
|
|
||||||
case <-tasksDone:
|
|
||||||
}
|
|
||||||
|
|
||||||
// Call shutdown handlers, if any.
|
|
||||||
// Timeout after 10 seconds.
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
for _, h := range eng.onShutdown {
|
|
||||||
wg.Add(1)
|
|
||||||
go func(h func()) {
|
|
||||||
defer wg.Done()
|
|
||||||
h()
|
|
||||||
}(h)
|
|
||||||
}
|
|
||||||
done := make(chan struct{})
|
|
||||||
go func() {
|
|
||||||
wg.Wait()
|
|
||||||
close(done)
|
|
||||||
}()
|
|
||||||
select {
|
|
||||||
case <-time.After(time.Second * 10):
|
|
||||||
case <-done:
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// IsShutdown returns true if the engine is in the process
|
|
||||||
// of shutting down, or already shut down.
|
|
||||||
// Otherwise it returns false.
|
|
||||||
func (eng *Engine) IsShutdown() bool {
|
|
||||||
eng.l.RLock()
|
|
||||||
defer eng.l.RUnlock()
|
|
||||||
return eng.shutdown
|
|
||||||
}
|
|
||||||
|
|
||||||
// ParseJob creates a new job from a text description using a shell-like syntax.
|
|
||||||
//
|
|
||||||
// The following syntax is used to parse `input`:
|
|
||||||
//
|
|
||||||
// * Words are separated using standard whitespaces as separators.
|
|
||||||
// * Quotes and backslashes are not interpreted.
|
|
||||||
// * Words of the form 'KEY=[VALUE]' are added to the job environment.
|
|
||||||
// * All other words are added to the job arguments.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// job, _ := eng.ParseJob("VERBOSE=1 echo hello TEST=true world")
|
|
||||||
//
|
|
||||||
// The resulting job will have:
|
|
||||||
// job.Args={"echo", "hello", "world"}
|
|
||||||
// job.Env={"VERBOSE":"1", "TEST":"true"}
|
|
||||||
//
|
|
||||||
func (eng *Engine) ParseJob(input string) (*Job, error) {
|
|
||||||
// FIXME: use a full-featured command parser
|
|
||||||
scanner := bufio.NewScanner(strings.NewReader(input))
|
|
||||||
scanner.Split(bufio.ScanWords)
|
|
||||||
var (
|
|
||||||
cmd []string
|
|
||||||
env Env
|
|
||||||
)
|
|
||||||
for scanner.Scan() {
|
|
||||||
word := scanner.Text()
|
|
||||||
kv := strings.SplitN(word, "=", 2)
|
|
||||||
if len(kv) == 2 {
|
|
||||||
env.Set(kv[0], kv[1])
|
|
||||||
} else {
|
|
||||||
cmd = append(cmd, word)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(cmd) == 0 {
|
|
||||||
return nil, fmt.Errorf("empty command: '%s'", input)
|
|
||||||
}
|
|
||||||
job := eng.Job(cmd[0], cmd[1:]...)
|
|
||||||
job.Env().Init(&env)
|
|
||||||
return job, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,236 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/ioutils"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestRegister(t *testing.T) {
|
|
||||||
if err := Register("dummy1", nil); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := Register("dummy1", nil); err == nil {
|
|
||||||
t.Fatalf("Expecting error, got none")
|
|
||||||
}
|
|
||||||
// Register is global so let's cleanup to avoid conflicts
|
|
||||||
defer unregister("dummy1")
|
|
||||||
|
|
||||||
eng := New()
|
|
||||||
|
|
||||||
//Should fail because global handlers are copied
|
|
||||||
//at the engine creation
|
|
||||||
if err := eng.Register("dummy1", nil); err == nil {
|
|
||||||
t.Fatalf("Expecting error, got none")
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := eng.Register("dummy2", nil); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := eng.Register("dummy2", nil); err == nil {
|
|
||||||
t.Fatalf("Expecting error, got none")
|
|
||||||
}
|
|
||||||
defer unregister("dummy2")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestJob(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
job1 := eng.Job("dummy1", "--level=awesome")
|
|
||||||
|
|
||||||
if job1.handler != nil {
|
|
||||||
t.Fatalf("job1.handler should be empty")
|
|
||||||
}
|
|
||||||
|
|
||||||
h := func(j *Job) Status {
|
|
||||||
j.Printf("%s\n", j.Name)
|
|
||||||
return 42
|
|
||||||
}
|
|
||||||
|
|
||||||
eng.Register("dummy2", h)
|
|
||||||
defer unregister("dummy2")
|
|
||||||
job2 := eng.Job("dummy2", "--level=awesome")
|
|
||||||
|
|
||||||
if job2.handler == nil {
|
|
||||||
t.Fatalf("job2.handler shouldn't be nil")
|
|
||||||
}
|
|
||||||
|
|
||||||
if job2.handler(job2) != 42 {
|
|
||||||
t.Fatalf("handler dummy2 was not found in job2")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEngineShutdown(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
if eng.IsShutdown() {
|
|
||||||
t.Fatalf("Engine should not show as shutdown")
|
|
||||||
}
|
|
||||||
eng.Shutdown()
|
|
||||||
if !eng.IsShutdown() {
|
|
||||||
t.Fatalf("Engine should show as shutdown")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEngineCommands(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
handler := func(job *Job) Status { return StatusOK }
|
|
||||||
eng.Register("foo", handler)
|
|
||||||
eng.Register("bar", handler)
|
|
||||||
eng.Register("echo", handler)
|
|
||||||
eng.Register("die", handler)
|
|
||||||
var output bytes.Buffer
|
|
||||||
commands := eng.Job("commands")
|
|
||||||
commands.Stdout.Add(&output)
|
|
||||||
commands.Run()
|
|
||||||
expected := "bar\ncommands\ndie\necho\nfoo\n"
|
|
||||||
if result := output.String(); result != expected {
|
|
||||||
t.Fatalf("Unexpected output:\nExpected = %v\nResult = %v\n", expected, result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEngineString(t *testing.T) {
|
|
||||||
eng1 := New()
|
|
||||||
eng2 := New()
|
|
||||||
s1 := eng1.String()
|
|
||||||
s2 := eng2.String()
|
|
||||||
if eng1 == eng2 {
|
|
||||||
t.Fatalf("Different engines should have different names (%v == %v)", s1, s2)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseJob(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
// Verify that the resulting job calls to the right place
|
|
||||||
var called bool
|
|
||||||
eng.Register("echo", func(job *Job) Status {
|
|
||||||
called = true
|
|
||||||
return StatusOK
|
|
||||||
})
|
|
||||||
input := "echo DEBUG=1 hello world VERBOSITY=42"
|
|
||||||
job, err := eng.ParseJob(input)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if job.Name != "echo" {
|
|
||||||
t.Fatalf("Invalid job name: %v", job.Name)
|
|
||||||
}
|
|
||||||
if strings.Join(job.Args, ":::") != "hello:::world" {
|
|
||||||
t.Fatalf("Invalid job args: %v", job.Args)
|
|
||||||
}
|
|
||||||
if job.Env().Get("DEBUG") != "1" {
|
|
||||||
t.Fatalf("Invalid job env: %v", job.Env)
|
|
||||||
}
|
|
||||||
if job.Env().Get("VERBOSITY") != "42" {
|
|
||||||
t.Fatalf("Invalid job env: %v", job.Env)
|
|
||||||
}
|
|
||||||
if len(job.Env().Map()) != 2 {
|
|
||||||
t.Fatalf("Invalid job env: %v", job.Env)
|
|
||||||
}
|
|
||||||
if err := job.Run(); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if !called {
|
|
||||||
t.Fatalf("Job was not called")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCatchallEmptyName(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
var called bool
|
|
||||||
eng.RegisterCatchall(func(job *Job) Status {
|
|
||||||
called = true
|
|
||||||
return StatusOK
|
|
||||||
})
|
|
||||||
err := eng.Job("").Run()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("Engine.Job(\"\").Run() should return an error")
|
|
||||||
}
|
|
||||||
if called {
|
|
||||||
t.Fatalf("Engine.Job(\"\").Run() should return an error")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Ensure that a job within a job both using the same underlying standard
|
|
||||||
// output writer does not close the output of the outer job when the inner
|
|
||||||
// job's stdout is wrapped with a NopCloser. When not wrapped, it should
|
|
||||||
// close the outer job's output.
|
|
||||||
func TestNestedJobSharedOutput(t *testing.T) {
|
|
||||||
var (
|
|
||||||
outerHandler Handler
|
|
||||||
innerHandler Handler
|
|
||||||
wrapOutput bool
|
|
||||||
)
|
|
||||||
|
|
||||||
outerHandler = func(job *Job) Status {
|
|
||||||
job.Stdout.Write([]byte("outer1"))
|
|
||||||
|
|
||||||
innerJob := job.Eng.Job("innerJob")
|
|
||||||
|
|
||||||
if wrapOutput {
|
|
||||||
innerJob.Stdout.Add(ioutils.NopWriteCloser(job.Stdout))
|
|
||||||
} else {
|
|
||||||
innerJob.Stdout.Add(job.Stdout)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := innerJob.Run(); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// If wrapOutput was *false* this write will do nothing.
|
|
||||||
// FIXME (jlhawn): It should cause an error to write to
|
|
||||||
// closed output.
|
|
||||||
job.Stdout.Write([]byte(" outer2"))
|
|
||||||
|
|
||||||
return StatusOK
|
|
||||||
}
|
|
||||||
|
|
||||||
innerHandler = func(job *Job) Status {
|
|
||||||
job.Stdout.Write([]byte(" inner"))
|
|
||||||
|
|
||||||
return StatusOK
|
|
||||||
}
|
|
||||||
|
|
||||||
eng := New()
|
|
||||||
eng.Register("outerJob", outerHandler)
|
|
||||||
eng.Register("innerJob", innerHandler)
|
|
||||||
|
|
||||||
// wrapOutput starts *false* so the expected
|
|
||||||
// output of running the outer job will be:
|
|
||||||
//
|
|
||||||
// "outer1 inner"
|
|
||||||
//
|
|
||||||
outBuf := new(bytes.Buffer)
|
|
||||||
outerJob := eng.Job("outerJob")
|
|
||||||
outerJob.Stdout.Add(outBuf)
|
|
||||||
|
|
||||||
if err := outerJob.Run(); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
expectedOutput := "outer1 inner"
|
|
||||||
if outBuf.String() != expectedOutput {
|
|
||||||
t.Fatalf("expected job output to be %q, got %q", expectedOutput, outBuf.String())
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set wrapOutput to true so that the expected
|
|
||||||
// output of running the outer job will be:
|
|
||||||
//
|
|
||||||
// "outer1 inner outer2"
|
|
||||||
//
|
|
||||||
wrapOutput = true
|
|
||||||
outBuf.Reset()
|
|
||||||
outerJob = eng.Job("outerJob")
|
|
||||||
outerJob.Stdout.Add(outBuf)
|
|
||||||
|
|
||||||
if err := outerJob.Run(); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
expectedOutput = "outer1 inner outer2"
|
|
||||||
if outBuf.String() != expectedOutput {
|
|
||||||
t.Fatalf("expected job output to be %q, got %q", expectedOutput, outBuf.String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,297 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/json"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Env []string
|
|
||||||
|
|
||||||
// Get returns the last value associated with the given key. If there are no
|
|
||||||
// values associated with the key, Get returns the empty string.
|
|
||||||
func (env *Env) Get(key string) (value string) {
|
|
||||||
// not using Map() because of the extra allocations https://github.com/docker/docker/pull/7488#issuecomment-51638315
|
|
||||||
for _, kv := range *env {
|
|
||||||
if strings.Index(kv, "=") == -1 {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
parts := strings.SplitN(kv, "=", 2)
|
|
||||||
if parts[0] != key {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if len(parts) < 2 {
|
|
||||||
value = ""
|
|
||||||
} else {
|
|
||||||
value = parts[1]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) Exists(key string) bool {
|
|
||||||
_, exists := env.Map()[key]
|
|
||||||
return exists
|
|
||||||
}
|
|
||||||
|
|
||||||
// Len returns the number of keys in the environment.
|
|
||||||
// Note that len(env) might be different from env.Len(),
|
|
||||||
// because the same key might be set multiple times.
|
|
||||||
func (env *Env) Len() int {
|
|
||||||
return len(env.Map())
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) Init(src *Env) {
|
|
||||||
(*env) = make([]string, 0, len(*src))
|
|
||||||
for _, val := range *src {
|
|
||||||
(*env) = append((*env), val)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) GetBool(key string) (value bool) {
|
|
||||||
s := strings.ToLower(strings.Trim(env.Get(key), " \t"))
|
|
||||||
if s == "" || s == "0" || s == "no" || s == "false" || s == "none" {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) SetBool(key string, value bool) {
|
|
||||||
if value {
|
|
||||||
env.Set(key, "1")
|
|
||||||
} else {
|
|
||||||
env.Set(key, "0")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) GetInt(key string) int {
|
|
||||||
return int(env.GetInt64(key))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) GetInt64(key string) int64 {
|
|
||||||
s := strings.Trim(env.Get(key), " \t")
|
|
||||||
val, err := strconv.ParseInt(s, 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
return val
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) SetInt(key string, value int) {
|
|
||||||
env.Set(key, fmt.Sprintf("%d", value))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) SetInt64(key string, value int64) {
|
|
||||||
env.Set(key, fmt.Sprintf("%d", value))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns nil if key not found
|
|
||||||
func (env *Env) GetList(key string) []string {
|
|
||||||
sval := env.Get(key)
|
|
||||||
if sval == "" {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
l := make([]string, 0, 1)
|
|
||||||
if err := json.Unmarshal([]byte(sval), &l); err != nil {
|
|
||||||
l = append(l, sval)
|
|
||||||
}
|
|
||||||
return l
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) GetSubEnv(key string) *Env {
|
|
||||||
sval := env.Get(key)
|
|
||||||
if sval == "" {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
buf := bytes.NewBufferString(sval)
|
|
||||||
var sub Env
|
|
||||||
if err := sub.Decode(buf); err != nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return &sub
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) SetSubEnv(key string, sub *Env) error {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
if err := sub.Encode(&buf); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
env.Set(key, string(buf.Bytes()))
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) GetJson(key string, iface interface{}) error {
|
|
||||||
sval := env.Get(key)
|
|
||||||
if sval == "" {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return json.Unmarshal([]byte(sval), iface)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) SetJson(key string, value interface{}) error {
|
|
||||||
sval, err := json.Marshal(value)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
env.Set(key, string(sval))
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) SetList(key string, value []string) error {
|
|
||||||
return env.SetJson(key, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) Set(key, value string) {
|
|
||||||
*env = append(*env, key+"="+value)
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewDecoder(src io.Reader) *Decoder {
|
|
||||||
return &Decoder{
|
|
||||||
json.NewDecoder(src),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type Decoder struct {
|
|
||||||
*json.Decoder
|
|
||||||
}
|
|
||||||
|
|
||||||
func (decoder *Decoder) Decode() (*Env, error) {
|
|
||||||
m := make(map[string]interface{})
|
|
||||||
if err := decoder.Decoder.Decode(&m); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
env := &Env{}
|
|
||||||
for key, value := range m {
|
|
||||||
env.SetAuto(key, value)
|
|
||||||
}
|
|
||||||
return env, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// DecodeEnv decodes `src` as a json dictionary, and adds
|
|
||||||
// each decoded key-value pair to the environment.
|
|
||||||
//
|
|
||||||
// If `src` cannot be decoded as a json dictionary, an error
|
|
||||||
// is returned.
|
|
||||||
func (env *Env) Decode(src io.Reader) error {
|
|
||||||
m := make(map[string]interface{})
|
|
||||||
if err := json.NewDecoder(src).Decode(&m); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
for k, v := range m {
|
|
||||||
env.SetAuto(k, v)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) SetAuto(k string, v interface{}) {
|
|
||||||
// Issue 7941 - if the value in the incoming JSON is null then treat it
|
|
||||||
// as if they never specified the property at all.
|
|
||||||
if v == nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// FIXME: we fix-convert float values to int, because
|
|
||||||
// encoding/json decodes integers to float64, but cannot encode them back.
|
|
||||||
// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)
|
|
||||||
if fval, ok := v.(float64); ok {
|
|
||||||
env.SetInt64(k, int64(fval))
|
|
||||||
} else if sval, ok := v.(string); ok {
|
|
||||||
env.Set(k, sval)
|
|
||||||
} else if val, err := json.Marshal(v); err == nil {
|
|
||||||
env.Set(k, string(val))
|
|
||||||
} else {
|
|
||||||
env.Set(k, fmt.Sprintf("%v", v))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func changeFloats(v interface{}) interface{} {
|
|
||||||
switch v := v.(type) {
|
|
||||||
case float64:
|
|
||||||
return int(v)
|
|
||||||
case map[string]interface{}:
|
|
||||||
for key, val := range v {
|
|
||||||
v[key] = changeFloats(val)
|
|
||||||
}
|
|
||||||
case []interface{}:
|
|
||||||
for idx, val := range v {
|
|
||||||
v[idx] = changeFloats(val)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return v
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) Encode(dst io.Writer) error {
|
|
||||||
m := make(map[string]interface{})
|
|
||||||
for k, v := range env.Map() {
|
|
||||||
var val interface{}
|
|
||||||
if err := json.Unmarshal([]byte(v), &val); err == nil {
|
|
||||||
// FIXME: we fix-convert float values to int, because
|
|
||||||
// encoding/json decodes integers to float64, but cannot encode them back.
|
|
||||||
// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)
|
|
||||||
m[k] = changeFloats(val)
|
|
||||||
} else {
|
|
||||||
m[k] = v
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if err := json.NewEncoder(dst).Encode(&m); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) WriteTo(dst io.Writer) (n int64, err error) {
|
|
||||||
// FIXME: return the number of bytes written to respect io.WriterTo
|
|
||||||
return 0, env.Encode(dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) Import(src interface{}) (err error) {
|
|
||||||
defer func() {
|
|
||||||
if err != nil {
|
|
||||||
err = fmt.Errorf("ImportEnv: %s", err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
var buf bytes.Buffer
|
|
||||||
if err := json.NewEncoder(&buf).Encode(src); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if err := env.Decode(&buf); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (env *Env) Map() map[string]string {
|
|
||||||
m := make(map[string]string)
|
|
||||||
for _, kv := range *env {
|
|
||||||
parts := strings.SplitN(kv, "=", 2)
|
|
||||||
m[parts[0]] = parts[1]
|
|
||||||
}
|
|
||||||
return m
|
|
||||||
}
|
|
||||||
|
|
||||||
// MultiMap returns a representation of env as a
|
|
||||||
// map of string arrays, keyed by string.
|
|
||||||
// This is the same structure as http headers for example,
|
|
||||||
// which allow each key to have multiple values.
|
|
||||||
func (env *Env) MultiMap() map[string][]string {
|
|
||||||
m := make(map[string][]string)
|
|
||||||
for _, kv := range *env {
|
|
||||||
parts := strings.SplitN(kv, "=", 2)
|
|
||||||
m[parts[0]] = append(m[parts[0]], parts[1])
|
|
||||||
}
|
|
||||||
return m
|
|
||||||
}
|
|
||||||
|
|
||||||
// InitMultiMap removes all values in env, then initializes
|
|
||||||
// new values from the contents of m.
|
|
||||||
func (env *Env) InitMultiMap(m map[string][]string) {
|
|
||||||
(*env) = make([]string, 0, len(m))
|
|
||||||
for k, vals := range m {
|
|
||||||
for _, v := range vals {
|
|
||||||
env.Set(k, v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,324 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/json"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/testutils"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestEnvLenZero(t *testing.T) {
|
|
||||||
env := &Env{}
|
|
||||||
if env.Len() != 0 {
|
|
||||||
t.Fatalf("%d", env.Len())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEnvLenNotZero(t *testing.T) {
|
|
||||||
env := &Env{}
|
|
||||||
env.Set("foo", "bar")
|
|
||||||
env.Set("ga", "bu")
|
|
||||||
if env.Len() != 2 {
|
|
||||||
t.Fatalf("%d", env.Len())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEnvLenDup(t *testing.T) {
|
|
||||||
env := &Env{
|
|
||||||
"foo=bar",
|
|
||||||
"foo=baz",
|
|
||||||
"a=b",
|
|
||||||
}
|
|
||||||
// len(env) != env.Len()
|
|
||||||
if env.Len() != 2 {
|
|
||||||
t.Fatalf("%d", env.Len())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEnvGetDup(t *testing.T) {
|
|
||||||
env := &Env{
|
|
||||||
"foo=bar",
|
|
||||||
"foo=baz",
|
|
||||||
"foo=bif",
|
|
||||||
}
|
|
||||||
expected := "bif"
|
|
||||||
if v := env.Get("foo"); v != expected {
|
|
||||||
t.Fatalf("expect %q, got %q", expected, v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestNewJob(t *testing.T) {
|
|
||||||
job := mkJob(t, "dummy", "--level=awesome")
|
|
||||||
if job.Name != "dummy" {
|
|
||||||
t.Fatalf("Wrong job name: %s", job.Name)
|
|
||||||
}
|
|
||||||
if len(job.Args) != 1 {
|
|
||||||
t.Fatalf("Wrong number of job arguments: %d", len(job.Args))
|
|
||||||
}
|
|
||||||
if job.Args[0] != "--level=awesome" {
|
|
||||||
t.Fatalf("Wrong job arguments: %s", job.Args[0])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSetenv(t *testing.T) {
|
|
||||||
job := mkJob(t, "dummy")
|
|
||||||
job.Setenv("foo", "bar")
|
|
||||||
if val := job.Getenv("foo"); val != "bar" {
|
|
||||||
t.Fatalf("Getenv returns incorrect value: %s", val)
|
|
||||||
}
|
|
||||||
|
|
||||||
job.Setenv("bar", "")
|
|
||||||
if val := job.Getenv("bar"); val != "" {
|
|
||||||
t.Fatalf("Getenv returns incorrect value: %s", val)
|
|
||||||
}
|
|
||||||
if val := job.Getenv("nonexistent"); val != "" {
|
|
||||||
t.Fatalf("Getenv returns incorrect value: %s", val)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSetenvBool(t *testing.T) {
|
|
||||||
job := mkJob(t, "dummy")
|
|
||||||
job.SetenvBool("foo", true)
|
|
||||||
if val := job.GetenvBool("foo"); !val {
|
|
||||||
t.Fatalf("GetenvBool returns incorrect value: %t", val)
|
|
||||||
}
|
|
||||||
|
|
||||||
job.SetenvBool("bar", false)
|
|
||||||
if val := job.GetenvBool("bar"); val {
|
|
||||||
t.Fatalf("GetenvBool returns incorrect value: %t", val)
|
|
||||||
}
|
|
||||||
|
|
||||||
if val := job.GetenvBool("nonexistent"); val {
|
|
||||||
t.Fatalf("GetenvBool returns incorrect value: %t", val)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSetenvInt(t *testing.T) {
|
|
||||||
job := mkJob(t, "dummy")
|
|
||||||
|
|
||||||
job.SetenvInt("foo", -42)
|
|
||||||
if val := job.GetenvInt("foo"); val != -42 {
|
|
||||||
t.Fatalf("GetenvInt returns incorrect value: %d", val)
|
|
||||||
}
|
|
||||||
|
|
||||||
job.SetenvInt("bar", 42)
|
|
||||||
if val := job.GetenvInt("bar"); val != 42 {
|
|
||||||
t.Fatalf("GetenvInt returns incorrect value: %d", val)
|
|
||||||
}
|
|
||||||
if val := job.GetenvInt("nonexistent"); val != 0 {
|
|
||||||
t.Fatalf("GetenvInt returns incorrect value: %d", val)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSetenvList(t *testing.T) {
|
|
||||||
job := mkJob(t, "dummy")
|
|
||||||
|
|
||||||
job.SetenvList("foo", []string{"bar"})
|
|
||||||
if val := job.GetenvList("foo"); len(val) != 1 || val[0] != "bar" {
|
|
||||||
t.Fatalf("GetenvList returns incorrect value: %v", val)
|
|
||||||
}
|
|
||||||
|
|
||||||
job.SetenvList("bar", nil)
|
|
||||||
if val := job.GetenvList("bar"); val != nil {
|
|
||||||
t.Fatalf("GetenvList returns incorrect value: %v", val)
|
|
||||||
}
|
|
||||||
if val := job.GetenvList("nonexistent"); val != nil {
|
|
||||||
t.Fatalf("GetenvList returns incorrect value: %v", val)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEnviron(t *testing.T) {
|
|
||||||
job := mkJob(t, "dummy")
|
|
||||||
job.Setenv("foo", "bar")
|
|
||||||
val, exists := job.Environ()["foo"]
|
|
||||||
if !exists {
|
|
||||||
t.Fatalf("foo not found in the environ")
|
|
||||||
}
|
|
||||||
if val != "bar" {
|
|
||||||
t.Fatalf("bar not found in the environ")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestMultiMap(t *testing.T) {
|
|
||||||
e := &Env{}
|
|
||||||
e.Set("foo", "bar")
|
|
||||||
e.Set("bar", "baz")
|
|
||||||
e.Set("hello", "world")
|
|
||||||
m := e.MultiMap()
|
|
||||||
e2 := &Env{}
|
|
||||||
e2.Set("old_key", "something something something")
|
|
||||||
e2.InitMultiMap(m)
|
|
||||||
if v := e2.Get("old_key"); v != "" {
|
|
||||||
t.Fatalf("%#v", v)
|
|
||||||
}
|
|
||||||
if v := e2.Get("bar"); v != "baz" {
|
|
||||||
t.Fatalf("%#v", v)
|
|
||||||
}
|
|
||||||
if v := e2.Get("hello"); v != "world" {
|
|
||||||
t.Fatalf("%#v", v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func testMap(l int) [][2]string {
|
|
||||||
res := make([][2]string, l)
|
|
||||||
for i := 0; i < l; i++ {
|
|
||||||
t := [2]string{testutils.RandomString(5), testutils.RandomString(20)}
|
|
||||||
res[i] = t
|
|
||||||
}
|
|
||||||
return res
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkSet(b *testing.B) {
|
|
||||||
fix := testMap(100)
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
env := &Env{}
|
|
||||||
for _, kv := range fix {
|
|
||||||
env.Set(kv[0], kv[1])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkSetJson(b *testing.B) {
|
|
||||||
fix := testMap(100)
|
|
||||||
type X struct {
|
|
||||||
f string
|
|
||||||
}
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
env := &Env{}
|
|
||||||
for _, kv := range fix {
|
|
||||||
if err := env.SetJson(kv[0], X{kv[1]}); err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkGet(b *testing.B) {
|
|
||||||
fix := testMap(100)
|
|
||||||
env := &Env{}
|
|
||||||
for _, kv := range fix {
|
|
||||||
env.Set(kv[0], kv[1])
|
|
||||||
}
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
for _, kv := range fix {
|
|
||||||
env.Get(kv[0])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkGetJson(b *testing.B) {
|
|
||||||
fix := testMap(100)
|
|
||||||
env := &Env{}
|
|
||||||
type X struct {
|
|
||||||
f string
|
|
||||||
}
|
|
||||||
for _, kv := range fix {
|
|
||||||
env.SetJson(kv[0], X{kv[1]})
|
|
||||||
}
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
for _, kv := range fix {
|
|
||||||
if err := env.GetJson(kv[0], &X{}); err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkEncode(b *testing.B) {
|
|
||||||
fix := testMap(100)
|
|
||||||
env := &Env{}
|
|
||||||
type X struct {
|
|
||||||
f string
|
|
||||||
}
|
|
||||||
// half a json
|
|
||||||
for i, kv := range fix {
|
|
||||||
if i%2 != 0 {
|
|
||||||
if err := env.SetJson(kv[0], X{kv[1]}); err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
env.Set(kv[0], kv[1])
|
|
||||||
}
|
|
||||||
var writer bytes.Buffer
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
env.Encode(&writer)
|
|
||||||
writer.Reset()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkDecode(b *testing.B) {
|
|
||||||
fix := testMap(100)
|
|
||||||
env := &Env{}
|
|
||||||
type X struct {
|
|
||||||
f string
|
|
||||||
}
|
|
||||||
// half a json
|
|
||||||
for i, kv := range fix {
|
|
||||||
if i%2 != 0 {
|
|
||||||
if err := env.SetJson(kv[0], X{kv[1]}); err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
env.Set(kv[0], kv[1])
|
|
||||||
}
|
|
||||||
var writer bytes.Buffer
|
|
||||||
env.Encode(&writer)
|
|
||||||
denv := &Env{}
|
|
||||||
reader := bytes.NewReader(writer.Bytes())
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
err := denv.Decode(reader)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
reader.Seek(0, 0)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestLongNumbers(t *testing.T) {
|
|
||||||
type T struct {
|
|
||||||
TestNum int64
|
|
||||||
}
|
|
||||||
v := T{67108864}
|
|
||||||
var buf bytes.Buffer
|
|
||||||
e := &Env{}
|
|
||||||
e.SetJson("Test", v)
|
|
||||||
if err := e.Encode(&buf); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
res := make(map[string]T)
|
|
||||||
if err := json.Unmarshal(buf.Bytes(), &res); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if res["Test"].TestNum != v.TestNum {
|
|
||||||
t.Fatalf("TestNum %d, expected %d", res["Test"].TestNum, v.TestNum)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestLongNumbersArray(t *testing.T) {
|
|
||||||
type T struct {
|
|
||||||
TestNum []int64
|
|
||||||
}
|
|
||||||
v := T{[]int64{67108864}}
|
|
||||||
var buf bytes.Buffer
|
|
||||||
e := &Env{}
|
|
||||||
e.SetJson("Test", v)
|
|
||||||
if err := e.Encode(&buf); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
res := make(map[string]T)
|
|
||||||
if err := json.Unmarshal(buf.Bytes(), &res); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if res["Test"].TestNum[0] != v.TestNum[0] {
|
|
||||||
t.Fatalf("TestNum %d, expected %d", res["Test"].TestNum, v.TestNum)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
type Hack map[string]interface{}
|
|
||||||
|
|
||||||
func (eng *Engine) Hack_GetGlobalVar(key string) interface{} {
|
|
||||||
if eng.hack == nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
val, exists := eng.hack[key]
|
|
||||||
if !exists {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return val
|
|
||||||
}
|
|
||||||
|
|
||||||
func (eng *Engine) Hack_SetGlobalVar(key string, val interface{}) {
|
|
||||||
if eng.hack == nil {
|
|
||||||
eng.hack = make(Hack)
|
|
||||||
}
|
|
||||||
eng.hack[key] = val
|
|
||||||
}
|
|
||||||
|
|
@ -1,11 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
var globalTestID string
|
|
||||||
|
|
||||||
func mkJob(t *testing.T, name string, args ...string) *Job {
|
|
||||||
return New().Job(name, args...)
|
|
||||||
}
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"net/http"
|
|
||||||
"path"
|
|
||||||
)
|
|
||||||
|
|
||||||
// ServeHTTP executes a job as specified by the http request `r`, and sends the
|
|
||||||
// result as an http response.
|
|
||||||
// This method allows an Engine instance to be passed as a standard http.Handler interface.
|
|
||||||
//
|
|
||||||
// Note that the protocol used in this method is a convenience wrapper and is not the canonical
|
|
||||||
// implementation of remote job execution. This is because HTTP/1 does not handle stream multiplexing,
|
|
||||||
// and so cannot differentiate stdout from stderr. Additionally, headers cannot be added to a response
|
|
||||||
// once data has been written to the body, which makes it inconvenient to return metadata such
|
|
||||||
// as the exit status.
|
|
||||||
//
|
|
||||||
func (eng *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
||||||
var (
|
|
||||||
jobName = path.Base(r.URL.Path)
|
|
||||||
jobArgs, exists = r.URL.Query()["a"]
|
|
||||||
)
|
|
||||||
if !exists {
|
|
||||||
jobArgs = []string{}
|
|
||||||
}
|
|
||||||
w.Header().Set("Job-Name", jobName)
|
|
||||||
for _, arg := range jobArgs {
|
|
||||||
w.Header().Add("Job-Args", arg)
|
|
||||||
}
|
|
||||||
job := eng.Job(jobName, jobArgs...)
|
|
||||||
job.Stdout.Add(w)
|
|
||||||
job.Stderr.Add(w)
|
|
||||||
// FIXME: distinguish job status from engine error in Run()
|
|
||||||
// The former should be passed as a special header, the former
|
|
||||||
// should cause a 500 status
|
|
||||||
w.WriteHeader(http.StatusOK)
|
|
||||||
// The exit status cannot be sent reliably with HTTP1, because headers
|
|
||||||
// can only be sent before the body.
|
|
||||||
// (we could possibly use http footers via chunked encoding, but I couldn't find
|
|
||||||
// how to use them in net/http)
|
|
||||||
job.Run()
|
|
||||||
}
|
|
||||||
|
|
@ -1,242 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
log "github.com/Sirupsen/logrus"
|
|
||||||
)
|
|
||||||
|
|
||||||
// A job is the fundamental unit of work in the docker engine.
|
|
||||||
// Everything docker can do should eventually be exposed as a job.
|
|
||||||
// For example: execute a process in a container, create a new container,
|
|
||||||
// download an archive from the internet, serve the http api, etc.
|
|
||||||
//
|
|
||||||
// The job API is designed after unix processes: a job has a name, arguments,
|
|
||||||
// environment variables, standard streams for input, output and error, and
|
|
||||||
// an exit status which can indicate success (0) or error (anything else).
|
|
||||||
//
|
|
||||||
// For status, 0 indicates success, and any other integers indicates an error.
|
|
||||||
// This allows for richer error reporting.
|
|
||||||
//
|
|
||||||
type Job struct {
|
|
||||||
Eng *Engine
|
|
||||||
Name string
|
|
||||||
Args []string
|
|
||||||
env *Env
|
|
||||||
Stdout *Output
|
|
||||||
Stderr *Output
|
|
||||||
Stdin *Input
|
|
||||||
handler Handler
|
|
||||||
status Status
|
|
||||||
end time.Time
|
|
||||||
closeIO bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type Status int
|
|
||||||
|
|
||||||
const (
|
|
||||||
StatusOK Status = 0
|
|
||||||
StatusErr Status = 1
|
|
||||||
StatusNotFound Status = 127
|
|
||||||
)
|
|
||||||
|
|
||||||
// Run executes the job and blocks until the job completes.
|
|
||||||
// If the job returns a failure status, an error is returned
|
|
||||||
// which includes the status.
|
|
||||||
func (job *Job) Run() error {
|
|
||||||
if job.Eng.IsShutdown() && !job.GetenvBool("overrideShutdown") {
|
|
||||||
return fmt.Errorf("engine is shutdown")
|
|
||||||
}
|
|
||||||
// FIXME: this is a temporary workaround to avoid Engine.Shutdown
|
|
||||||
// waiting 5 seconds for server/api.ServeApi to complete (which it never will)
|
|
||||||
// everytime the daemon is cleanly restarted.
|
|
||||||
// The permanent fix is to implement Job.Stop and Job.OnStop so that
|
|
||||||
// ServeApi can cooperate and terminate cleanly.
|
|
||||||
if job.Name != "serveapi" {
|
|
||||||
job.Eng.l.Lock()
|
|
||||||
job.Eng.tasks.Add(1)
|
|
||||||
job.Eng.l.Unlock()
|
|
||||||
defer job.Eng.tasks.Done()
|
|
||||||
}
|
|
||||||
// FIXME: make this thread-safe
|
|
||||||
// FIXME: implement wait
|
|
||||||
if !job.end.IsZero() {
|
|
||||||
return fmt.Errorf("%s: job has already completed", job.Name)
|
|
||||||
}
|
|
||||||
// Log beginning and end of the job
|
|
||||||
if job.Eng.Logging {
|
|
||||||
log.Infof("+job %s", job.CallString())
|
|
||||||
defer func() {
|
|
||||||
log.Infof("-job %s%s", job.CallString(), job.StatusString())
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
var errorMessage = bytes.NewBuffer(nil)
|
|
||||||
job.Stderr.Add(errorMessage)
|
|
||||||
if job.handler == nil {
|
|
||||||
job.Errorf("%s: command not found", job.Name)
|
|
||||||
job.status = 127
|
|
||||||
} else {
|
|
||||||
job.status = job.handler(job)
|
|
||||||
job.end = time.Now()
|
|
||||||
}
|
|
||||||
if job.closeIO {
|
|
||||||
// Wait for all background tasks to complete
|
|
||||||
if err := job.Stdout.Close(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if err := job.Stderr.Close(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if err := job.Stdin.Close(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if job.status != 0 {
|
|
||||||
return fmt.Errorf("%s", Tail(errorMessage, 1))
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) CallString() string {
|
|
||||||
return fmt.Sprintf("%s(%s)", job.Name, strings.Join(job.Args, ", "))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) StatusString() string {
|
|
||||||
// If the job hasn't completed, status string is empty
|
|
||||||
if job.end.IsZero() {
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
var okerr string
|
|
||||||
if job.status == StatusOK {
|
|
||||||
okerr = "OK"
|
|
||||||
} else {
|
|
||||||
okerr = "ERR"
|
|
||||||
}
|
|
||||||
return fmt.Sprintf(" = %s (%d)", okerr, job.status)
|
|
||||||
}
|
|
||||||
|
|
||||||
// String returns a human-readable description of `job`
|
|
||||||
func (job *Job) String() string {
|
|
||||||
return fmt.Sprintf("%s.%s%s", job.Eng, job.CallString(), job.StatusString())
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) Env() *Env {
|
|
||||||
return job.env
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) EnvExists(key string) (value bool) {
|
|
||||||
return job.env.Exists(key)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) Getenv(key string) (value string) {
|
|
||||||
return job.env.Get(key)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) GetenvBool(key string) (value bool) {
|
|
||||||
return job.env.GetBool(key)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) SetenvBool(key string, value bool) {
|
|
||||||
job.env.SetBool(key, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) GetenvSubEnv(key string) *Env {
|
|
||||||
return job.env.GetSubEnv(key)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) SetenvSubEnv(key string, value *Env) error {
|
|
||||||
return job.env.SetSubEnv(key, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) GetenvInt64(key string) int64 {
|
|
||||||
return job.env.GetInt64(key)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) GetenvInt(key string) int {
|
|
||||||
return job.env.GetInt(key)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) SetenvInt64(key string, value int64) {
|
|
||||||
job.env.SetInt64(key, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) SetenvInt(key string, value int) {
|
|
||||||
job.env.SetInt(key, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns nil if key not found
|
|
||||||
func (job *Job) GetenvList(key string) []string {
|
|
||||||
return job.env.GetList(key)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) GetenvJson(key string, iface interface{}) error {
|
|
||||||
return job.env.GetJson(key, iface)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) SetenvJson(key string, value interface{}) error {
|
|
||||||
return job.env.SetJson(key, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) SetenvList(key string, value []string) error {
|
|
||||||
return job.env.SetJson(key, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) Setenv(key, value string) {
|
|
||||||
job.env.Set(key, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
// DecodeEnv decodes `src` as a json dictionary, and adds
|
|
||||||
// each decoded key-value pair to the environment.
|
|
||||||
//
|
|
||||||
// If `src` cannot be decoded as a json dictionary, an error
|
|
||||||
// is returned.
|
|
||||||
func (job *Job) DecodeEnv(src io.Reader) error {
|
|
||||||
return job.env.Decode(src)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) EncodeEnv(dst io.Writer) error {
|
|
||||||
return job.env.Encode(dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) ImportEnv(src interface{}) (err error) {
|
|
||||||
return job.env.Import(src)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) Environ() map[string]string {
|
|
||||||
return job.env.Map()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) Logf(format string, args ...interface{}) (n int, err error) {
|
|
||||||
prefixedFormat := fmt.Sprintf("[%s] %s\n", job, strings.TrimRight(format, "\n"))
|
|
||||||
return fmt.Fprintf(job.Stderr, prefixedFormat, args...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) Printf(format string, args ...interface{}) (n int, err error) {
|
|
||||||
return fmt.Fprintf(job.Stdout, format, args...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) Errorf(format string, args ...interface{}) Status {
|
|
||||||
if format[len(format)-1] != '\n' {
|
|
||||||
format = format + "\n"
|
|
||||||
}
|
|
||||||
fmt.Fprintf(job.Stderr, format, args...)
|
|
||||||
return StatusErr
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) Error(err error) Status {
|
|
||||||
fmt.Fprintf(job.Stderr, "%s\n", err)
|
|
||||||
return StatusErr
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) StatusCode() int {
|
|
||||||
return int(job.status)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (job *Job) SetCloseIO(val bool) {
|
|
||||||
job.closeIO = val
|
|
||||||
}
|
|
||||||
|
|
@ -1,75 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestJobStatusOK(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
eng.Register("return_ok", func(job *Job) Status { return StatusOK })
|
|
||||||
err := eng.Job("return_ok").Run()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Expected: err=%v\nReceived: err=%v", nil, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestJobStatusErr(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
eng.Register("return_err", func(job *Job) Status { return StatusErr })
|
|
||||||
err := eng.Job("return_err").Run()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("When a job returns StatusErr, Run() should return an error")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestJobStatusNotFound(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
eng.Register("return_not_found", func(job *Job) Status { return StatusNotFound })
|
|
||||||
err := eng.Job("return_not_found").Run()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("When a job returns StatusNotFound, Run() should return an error")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestJobStdoutString(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
// FIXME: test multiple combinations of output and status
|
|
||||||
eng.Register("say_something_in_stdout", func(job *Job) Status {
|
|
||||||
job.Printf("Hello world\n")
|
|
||||||
return StatusOK
|
|
||||||
})
|
|
||||||
|
|
||||||
job := eng.Job("say_something_in_stdout")
|
|
||||||
var outputBuffer = bytes.NewBuffer(nil)
|
|
||||||
job.Stdout.Add(outputBuffer)
|
|
||||||
if err := job.Run(); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
fmt.Println(outputBuffer)
|
|
||||||
var output = Tail(outputBuffer, 1)
|
|
||||||
if expectedOutput := "Hello world"; output != expectedOutput {
|
|
||||||
t.Fatalf("Stdout last line:\nExpected: %v\nReceived: %v", expectedOutput, output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestJobStderrString(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
// FIXME: test multiple combinations of output and status
|
|
||||||
eng.Register("say_something_in_stderr", func(job *Job) Status {
|
|
||||||
job.Errorf("Warning, something might happen\nHere it comes!\nOh no...\nSomething happened\n")
|
|
||||||
return StatusOK
|
|
||||||
})
|
|
||||||
|
|
||||||
job := eng.Job("say_something_in_stderr")
|
|
||||||
var outputBuffer = bytes.NewBuffer(nil)
|
|
||||||
job.Stderr.Add(outputBuffer)
|
|
||||||
if err := job.Run(); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
var output = Tail(outputBuffer, 1)
|
|
||||||
if expectedOutput := "Something happened"; output != expectedOutput {
|
|
||||||
t.Fatalf("Stderr last line:\nExpected: %v\nReceived: %v", expectedOutput, output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,80 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestShutdownEmpty(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
if eng.IsShutdown() {
|
|
||||||
t.Fatalf("IsShutdown should be false")
|
|
||||||
}
|
|
||||||
eng.Shutdown()
|
|
||||||
if !eng.IsShutdown() {
|
|
||||||
t.Fatalf("IsShutdown should be true")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestShutdownAfterRun(t *testing.T) {
|
|
||||||
eng := New()
|
|
||||||
var called bool
|
|
||||||
eng.Register("foo", func(job *Job) Status {
|
|
||||||
called = true
|
|
||||||
return StatusOK
|
|
||||||
})
|
|
||||||
if err := eng.Job("foo").Run(); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
eng.Shutdown()
|
|
||||||
if err := eng.Job("foo").Run(); err == nil {
|
|
||||||
t.Fatalf("%#v", *eng)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// An approximate and racy, but better-than-nothing test that
|
|
||||||
//
|
|
||||||
func TestShutdownDuringRun(t *testing.T) {
|
|
||||||
var (
|
|
||||||
jobDelay time.Duration = 500 * time.Millisecond
|
|
||||||
jobDelayLow time.Duration = 100 * time.Millisecond
|
|
||||||
jobDelayHigh time.Duration = 700 * time.Millisecond
|
|
||||||
)
|
|
||||||
eng := New()
|
|
||||||
var completed bool
|
|
||||||
eng.Register("foo", func(job *Job) Status {
|
|
||||||
time.Sleep(jobDelay)
|
|
||||||
completed = true
|
|
||||||
return StatusOK
|
|
||||||
})
|
|
||||||
go eng.Job("foo").Run()
|
|
||||||
time.Sleep(50 * time.Millisecond)
|
|
||||||
done := make(chan struct{})
|
|
||||||
var startShutdown time.Time
|
|
||||||
go func() {
|
|
||||||
startShutdown = time.Now()
|
|
||||||
eng.Shutdown()
|
|
||||||
close(done)
|
|
||||||
}()
|
|
||||||
time.Sleep(50 * time.Millisecond)
|
|
||||||
if err := eng.Job("foo").Run(); err == nil {
|
|
||||||
t.Fatalf("run on shutdown should fail: %#v", *eng)
|
|
||||||
}
|
|
||||||
<-done
|
|
||||||
// Verify that Shutdown() blocks for roughly 500ms, instead
|
|
||||||
// of returning almost instantly.
|
|
||||||
//
|
|
||||||
// We use >100ms to leave ample margin for race conditions between
|
|
||||||
// goroutines. It's possible (but unlikely in reasonable testing
|
|
||||||
// conditions), that this test will cause a false positive or false
|
|
||||||
// negative. But it's probably better than not having any test
|
|
||||||
// for the 99.999% of time where testing conditions are reasonable.
|
|
||||||
if d := time.Since(startShutdown); d.Nanoseconds() < jobDelayLow.Nanoseconds() {
|
|
||||||
t.Fatalf("shutdown did not block long enough: %v", d)
|
|
||||||
} else if d.Nanoseconds() > jobDelayHigh.Nanoseconds() {
|
|
||||||
t.Fatalf("shutdown blocked too long: %v", d)
|
|
||||||
}
|
|
||||||
if !completed {
|
|
||||||
t.Fatalf("job did not complete")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,223 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Output struct {
|
|
||||||
sync.Mutex
|
|
||||||
dests []io.Writer
|
|
||||||
tasks sync.WaitGroup
|
|
||||||
used bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// Tail returns the n last lines of a buffer
|
|
||||||
// stripped out of the last \n, if any
|
|
||||||
// if n <= 0, returns an empty string
|
|
||||||
func Tail(buffer *bytes.Buffer, n int) string {
|
|
||||||
if n <= 0 {
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
bytes := buffer.Bytes()
|
|
||||||
if len(bytes) > 0 && bytes[len(bytes)-1] == '\n' {
|
|
||||||
bytes = bytes[:len(bytes)-1]
|
|
||||||
}
|
|
||||||
for i := buffer.Len() - 2; i >= 0; i-- {
|
|
||||||
if bytes[i] == '\n' {
|
|
||||||
n--
|
|
||||||
if n == 0 {
|
|
||||||
return string(bytes[i+1:])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return string(bytes)
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewOutput returns a new Output object with no destinations attached.
|
|
||||||
// Writing to an empty Output will cause the written data to be discarded.
|
|
||||||
func NewOutput() *Output {
|
|
||||||
return &Output{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return true if something was written on this output
|
|
||||||
func (o *Output) Used() bool {
|
|
||||||
o.Lock()
|
|
||||||
defer o.Unlock()
|
|
||||||
return o.used
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add attaches a new destination to the Output. Any data subsequently written
|
|
||||||
// to the output will be written to the new destination in addition to all the others.
|
|
||||||
// This method is thread-safe.
|
|
||||||
func (o *Output) Add(dst io.Writer) {
|
|
||||||
o.Lock()
|
|
||||||
defer o.Unlock()
|
|
||||||
o.dests = append(o.dests, dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set closes and remove existing destination and then attaches a new destination to
|
|
||||||
// the Output. Any data subsequently written to the output will be written to the new
|
|
||||||
// destination in addition to all the others. This method is thread-safe.
|
|
||||||
func (o *Output) Set(dst io.Writer) {
|
|
||||||
o.Close()
|
|
||||||
o.Lock()
|
|
||||||
defer o.Unlock()
|
|
||||||
o.dests = []io.Writer{dst}
|
|
||||||
}
|
|
||||||
|
|
||||||
// AddPipe creates an in-memory pipe with io.Pipe(), adds its writing end as a destination,
|
|
||||||
// and returns its reading end for consumption by the caller.
|
|
||||||
// This is a rough equivalent similar to Cmd.StdoutPipe() in the standard os/exec package.
|
|
||||||
// This method is thread-safe.
|
|
||||||
func (o *Output) AddPipe() (io.Reader, error) {
|
|
||||||
r, w := io.Pipe()
|
|
||||||
o.Add(w)
|
|
||||||
return r, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write writes the same data to all registered destinations.
|
|
||||||
// This method is thread-safe.
|
|
||||||
func (o *Output) Write(p []byte) (n int, err error) {
|
|
||||||
o.Lock()
|
|
||||||
defer o.Unlock()
|
|
||||||
o.used = true
|
|
||||||
var firstErr error
|
|
||||||
for _, dst := range o.dests {
|
|
||||||
_, err := dst.Write(p)
|
|
||||||
if err != nil && firstErr == nil {
|
|
||||||
firstErr = err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return len(p), firstErr
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close unregisters all destinations and waits for all background
|
|
||||||
// AddTail and AddString tasks to complete.
|
|
||||||
// The Close method of each destination is called if it exists.
|
|
||||||
func (o *Output) Close() error {
|
|
||||||
o.Lock()
|
|
||||||
defer o.Unlock()
|
|
||||||
var firstErr error
|
|
||||||
for _, dst := range o.dests {
|
|
||||||
if closer, ok := dst.(io.Closer); ok {
|
|
||||||
err := closer.Close()
|
|
||||||
if err != nil && firstErr == nil {
|
|
||||||
firstErr = err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
o.tasks.Wait()
|
|
||||||
o.dests = nil
|
|
||||||
return firstErr
|
|
||||||
}
|
|
||||||
|
|
||||||
type Input struct {
|
|
||||||
src io.Reader
|
|
||||||
sync.Mutex
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewInput returns a new Input object with no source attached.
|
|
||||||
// Reading to an empty Input will return io.EOF.
|
|
||||||
func NewInput() *Input {
|
|
||||||
return &Input{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Read reads from the input in a thread-safe way.
|
|
||||||
func (i *Input) Read(p []byte) (n int, err error) {
|
|
||||||
i.Mutex.Lock()
|
|
||||||
defer i.Mutex.Unlock()
|
|
||||||
if i.src == nil {
|
|
||||||
return 0, io.EOF
|
|
||||||
}
|
|
||||||
return i.src.Read(p)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Closes the src
|
|
||||||
// Not thread safe on purpose
|
|
||||||
func (i *Input) Close() error {
|
|
||||||
if i.src != nil {
|
|
||||||
if closer, ok := i.src.(io.Closer); ok {
|
|
||||||
return closer.Close()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add attaches a new source to the input.
|
|
||||||
// Add can only be called once per input. Subsequent calls will
|
|
||||||
// return an error.
|
|
||||||
func (i *Input) Add(src io.Reader) error {
|
|
||||||
i.Mutex.Lock()
|
|
||||||
defer i.Mutex.Unlock()
|
|
||||||
if i.src != nil {
|
|
||||||
return fmt.Errorf("Maximum number of sources reached: 1")
|
|
||||||
}
|
|
||||||
i.src = src
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// AddEnv starts a new goroutine which will decode all subsequent data
|
|
||||||
// as a stream of json-encoded objects, and point `dst` to the last
|
|
||||||
// decoded object.
|
|
||||||
// The result `env` can be queried using the type-neutral Env interface.
|
|
||||||
// It is not safe to query `env` until the Output is closed.
|
|
||||||
func (o *Output) AddEnv() (dst *Env, err error) {
|
|
||||||
src, err := o.AddPipe()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
dst = &Env{}
|
|
||||||
o.tasks.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer o.tasks.Done()
|
|
||||||
decoder := NewDecoder(src)
|
|
||||||
for {
|
|
||||||
env, err := decoder.Decode()
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
*dst = *env
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
return dst, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (o *Output) AddListTable() (dst *Table, err error) {
|
|
||||||
src, err := o.AddPipe()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
dst = NewTable("", 0)
|
|
||||||
o.tasks.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer o.tasks.Done()
|
|
||||||
content, err := ioutil.ReadAll(src)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if _, err := dst.ReadListFrom(content); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
return dst, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (o *Output) AddTable() (dst *Table, err error) {
|
|
||||||
src, err := o.AddPipe()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
dst = NewTable("", 0)
|
|
||||||
o.tasks.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer o.tasks.Done()
|
|
||||||
if _, err := dst.ReadFrom(src); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
return dst, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,210 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
type sentinelWriteCloser struct {
|
|
||||||
calledWrite bool
|
|
||||||
calledClose bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *sentinelWriteCloser) Write(p []byte) (int, error) {
|
|
||||||
w.calledWrite = true
|
|
||||||
return len(p), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *sentinelWriteCloser) Close() error {
|
|
||||||
w.calledClose = true
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestOutputAddEnv(t *testing.T) {
|
|
||||||
input := "{\"foo\": \"bar\", \"answer_to_life_the_universe_and_everything\": 42}"
|
|
||||||
o := NewOutput()
|
|
||||||
result, err := o.AddEnv()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
o.Write([]byte(input))
|
|
||||||
o.Close()
|
|
||||||
if v := result.Get("foo"); v != "bar" {
|
|
||||||
t.Errorf("Expected %v, got %v", "bar", v)
|
|
||||||
}
|
|
||||||
if v := result.GetInt("answer_to_life_the_universe_and_everything"); v != 42 {
|
|
||||||
t.Errorf("Expected %v, got %v", 42, v)
|
|
||||||
}
|
|
||||||
if v := result.Get("this-value-doesnt-exist"); v != "" {
|
|
||||||
t.Errorf("Expected %v, got %v", "", v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestOutputAddClose(t *testing.T) {
|
|
||||||
o := NewOutput()
|
|
||||||
var s sentinelWriteCloser
|
|
||||||
o.Add(&s)
|
|
||||||
if err := o.Close(); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
// Write data after the output is closed.
|
|
||||||
// Write should succeed, but no destination should receive it.
|
|
||||||
if _, err := o.Write([]byte("foo bar")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if !s.calledClose {
|
|
||||||
t.Fatal("Output.Close() didn't close the destination")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestOutputAddPipe(t *testing.T) {
|
|
||||||
var testInputs = []string{
|
|
||||||
"hello, world!",
|
|
||||||
"One\nTwo\nThree",
|
|
||||||
"",
|
|
||||||
"A line\nThen another nl-terminated line\n",
|
|
||||||
"A line followed by an empty line\n\n",
|
|
||||||
}
|
|
||||||
for _, input := range testInputs {
|
|
||||||
expectedOutput := input
|
|
||||||
o := NewOutput()
|
|
||||||
r, err := o.AddPipe()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
go func(o *Output) {
|
|
||||||
if n, err := o.Write([]byte(input)); err != nil {
|
|
||||||
t.Error(err)
|
|
||||||
} else if n != len(input) {
|
|
||||||
t.Errorf("Expected %d, got %d", len(input), n)
|
|
||||||
}
|
|
||||||
if err := o.Close(); err != nil {
|
|
||||||
t.Error(err)
|
|
||||||
}
|
|
||||||
}(o)
|
|
||||||
output, err := ioutil.ReadAll(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if string(output) != expectedOutput {
|
|
||||||
t.Errorf("Last line is not stored as return string.\nExpected: '%s'\nGot: '%s'", expectedOutput, output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTail(t *testing.T) {
|
|
||||||
var tests = make(map[string][]string)
|
|
||||||
tests["hello, world!"] = []string{
|
|
||||||
"",
|
|
||||||
"hello, world!",
|
|
||||||
"hello, world!",
|
|
||||||
"hello, world!",
|
|
||||||
}
|
|
||||||
tests["One\nTwo\nThree"] = []string{
|
|
||||||
"",
|
|
||||||
"Three",
|
|
||||||
"Two\nThree",
|
|
||||||
"One\nTwo\nThree",
|
|
||||||
}
|
|
||||||
for input, outputs := range tests {
|
|
||||||
for n, expectedOutput := range outputs {
|
|
||||||
output := Tail(bytes.NewBufferString(input), n)
|
|
||||||
if output != expectedOutput {
|
|
||||||
t.Errorf("Tail n=%d returned wrong result.\nExpected: '%s'\nGot : '%s'", n, expectedOutput, output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func lastLine(txt string) string {
|
|
||||||
scanner := bufio.NewScanner(strings.NewReader(txt))
|
|
||||||
var lastLine string
|
|
||||||
for scanner.Scan() {
|
|
||||||
lastLine = scanner.Text()
|
|
||||||
}
|
|
||||||
return lastLine
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestOutputAdd(t *testing.T) {
|
|
||||||
o := NewOutput()
|
|
||||||
b := &bytes.Buffer{}
|
|
||||||
o.Add(b)
|
|
||||||
input := "hello, world!"
|
|
||||||
if n, err := o.Write([]byte(input)); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
} else if n != len(input) {
|
|
||||||
t.Fatalf("Expected %d, got %d", len(input), n)
|
|
||||||
}
|
|
||||||
if output := b.String(); output != input {
|
|
||||||
t.Fatalf("Received wrong data from Add.\nExpected: '%s'\nGot: '%s'", input, output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestOutputWriteError(t *testing.T) {
|
|
||||||
o := NewOutput()
|
|
||||||
buf := &bytes.Buffer{}
|
|
||||||
o.Add(buf)
|
|
||||||
r, w := io.Pipe()
|
|
||||||
input := "Hello there"
|
|
||||||
expectedErr := fmt.Errorf("This is an error")
|
|
||||||
r.CloseWithError(expectedErr)
|
|
||||||
o.Add(w)
|
|
||||||
n, err := o.Write([]byte(input))
|
|
||||||
if err != expectedErr {
|
|
||||||
t.Fatalf("Output.Write() should return the first error encountered, if any")
|
|
||||||
}
|
|
||||||
if buf.String() != input {
|
|
||||||
t.Fatalf("Output.Write() should attempt write on all destinations, even after encountering an error")
|
|
||||||
}
|
|
||||||
if n != len(input) {
|
|
||||||
t.Fatalf("Output.Write() should return the size of the input if it successfully writes to at least one destination")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestInputAddEmpty(t *testing.T) {
|
|
||||||
i := NewInput()
|
|
||||||
var b bytes.Buffer
|
|
||||||
if err := i.Add(&b); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
data, err := ioutil.ReadAll(i)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if len(data) > 0 {
|
|
||||||
t.Fatalf("Read from empty input shoul yield no data")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestInputAddTwo(t *testing.T) {
|
|
||||||
i := NewInput()
|
|
||||||
var b1 bytes.Buffer
|
|
||||||
// First add should succeed
|
|
||||||
if err := i.Add(&b1); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
var b2 bytes.Buffer
|
|
||||||
// Second add should fail
|
|
||||||
if err := i.Add(&b2); err == nil {
|
|
||||||
t.Fatalf("Adding a second source should return an error")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestInputAddNotEmpty(t *testing.T) {
|
|
||||||
i := NewInput()
|
|
||||||
b := bytes.NewBufferString("hello world\nabc")
|
|
||||||
expectedResult := b.String()
|
|
||||||
i.Add(b)
|
|
||||||
result, err := ioutil.ReadAll(i)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if string(result) != expectedResult {
|
|
||||||
t.Fatalf("Expected: %v\nReceived: %v", expectedResult, result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,140 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/json"
|
|
||||||
"io"
|
|
||||||
"sort"
|
|
||||||
"strconv"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Table struct {
|
|
||||||
Data []*Env
|
|
||||||
sortKey string
|
|
||||||
Chan chan *Env
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewTable(sortKey string, sizeHint int) *Table {
|
|
||||||
return &Table{
|
|
||||||
make([]*Env, 0, sizeHint),
|
|
||||||
sortKey,
|
|
||||||
make(chan *Env),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) SetKey(sortKey string) {
|
|
||||||
t.sortKey = sortKey
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) Add(env *Env) {
|
|
||||||
t.Data = append(t.Data, env)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) Len() int {
|
|
||||||
return len(t.Data)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) Less(a, b int) bool {
|
|
||||||
return t.lessBy(a, b, t.sortKey)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) lessBy(a, b int, by string) bool {
|
|
||||||
keyA := t.Data[a].Get(by)
|
|
||||||
keyB := t.Data[b].Get(by)
|
|
||||||
intA, errA := strconv.ParseInt(keyA, 10, 64)
|
|
||||||
intB, errB := strconv.ParseInt(keyB, 10, 64)
|
|
||||||
if errA == nil && errB == nil {
|
|
||||||
return intA < intB
|
|
||||||
}
|
|
||||||
return keyA < keyB
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) Swap(a, b int) {
|
|
||||||
tmp := t.Data[a]
|
|
||||||
t.Data[a] = t.Data[b]
|
|
||||||
t.Data[b] = tmp
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) Sort() {
|
|
||||||
sort.Sort(t)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) ReverseSort() {
|
|
||||||
sort.Sort(sort.Reverse(t))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) WriteListTo(dst io.Writer) (n int64, err error) {
|
|
||||||
if _, err := dst.Write([]byte{'['}); err != nil {
|
|
||||||
return -1, err
|
|
||||||
}
|
|
||||||
n = 1
|
|
||||||
for i, env := range t.Data {
|
|
||||||
bytes, err := env.WriteTo(dst)
|
|
||||||
if err != nil {
|
|
||||||
return -1, err
|
|
||||||
}
|
|
||||||
n += bytes
|
|
||||||
if i != len(t.Data)-1 {
|
|
||||||
if _, err := dst.Write([]byte{','}); err != nil {
|
|
||||||
return -1, err
|
|
||||||
}
|
|
||||||
n++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if _, err := dst.Write([]byte{']'}); err != nil {
|
|
||||||
return -1, err
|
|
||||||
}
|
|
||||||
return n + 1, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) ToListString() (string, error) {
|
|
||||||
buffer := bytes.NewBuffer(nil)
|
|
||||||
if _, err := t.WriteListTo(buffer); err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
return buffer.String(), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) WriteTo(dst io.Writer) (n int64, err error) {
|
|
||||||
for _, env := range t.Data {
|
|
||||||
bytes, err := env.WriteTo(dst)
|
|
||||||
if err != nil {
|
|
||||||
return -1, err
|
|
||||||
}
|
|
||||||
n += bytes
|
|
||||||
}
|
|
||||||
return n, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) ReadListFrom(src []byte) (n int64, err error) {
|
|
||||||
var array []interface{}
|
|
||||||
|
|
||||||
if err := json.Unmarshal(src, &array); err != nil {
|
|
||||||
return -1, err
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, item := range array {
|
|
||||||
if m, ok := item.(map[string]interface{}); ok {
|
|
||||||
env := &Env{}
|
|
||||||
for key, value := range m {
|
|
||||||
env.SetAuto(key, value)
|
|
||||||
}
|
|
||||||
t.Add(env)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return int64(len(src)), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Table) ReadFrom(src io.Reader) (n int64, err error) {
|
|
||||||
decoder := NewDecoder(src)
|
|
||||||
for {
|
|
||||||
env, err := decoder.Decode()
|
|
||||||
if err == io.EOF {
|
|
||||||
return 0, nil
|
|
||||||
} else if err != nil {
|
|
||||||
return -1, err
|
|
||||||
}
|
|
||||||
t.Add(env)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,112 +0,0 @@
|
||||||
package engine
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/json"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestTableWriteTo(t *testing.T) {
|
|
||||||
table := NewTable("", 0)
|
|
||||||
e := &Env{}
|
|
||||||
e.Set("foo", "bar")
|
|
||||||
table.Add(e)
|
|
||||||
var buf bytes.Buffer
|
|
||||||
if _, err := table.WriteTo(&buf); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
output := make(map[string]string)
|
|
||||||
if err := json.Unmarshal(buf.Bytes(), &output); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if len(output) != 1 {
|
|
||||||
t.Fatalf("Incorrect output: %v", output)
|
|
||||||
}
|
|
||||||
if val, exists := output["foo"]; !exists || val != "bar" {
|
|
||||||
t.Fatalf("Inccorect output: %v", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTableSortStringValue(t *testing.T) {
|
|
||||||
table := NewTable("Key", 0)
|
|
||||||
|
|
||||||
e := &Env{}
|
|
||||||
e.Set("Key", "A")
|
|
||||||
table.Add(e)
|
|
||||||
|
|
||||||
e = &Env{}
|
|
||||||
e.Set("Key", "D")
|
|
||||||
table.Add(e)
|
|
||||||
|
|
||||||
e = &Env{}
|
|
||||||
e.Set("Key", "B")
|
|
||||||
table.Add(e)
|
|
||||||
|
|
||||||
e = &Env{}
|
|
||||||
e.Set("Key", "C")
|
|
||||||
table.Add(e)
|
|
||||||
|
|
||||||
table.Sort()
|
|
||||||
|
|
||||||
if len := table.Len(); len != 4 {
|
|
||||||
t.Fatalf("Expected 4, got %d", len)
|
|
||||||
}
|
|
||||||
|
|
||||||
if value := table.Data[0].Get("Key"); value != "A" {
|
|
||||||
t.Fatalf("Expected A, got %s", value)
|
|
||||||
}
|
|
||||||
|
|
||||||
if value := table.Data[1].Get("Key"); value != "B" {
|
|
||||||
t.Fatalf("Expected B, got %s", value)
|
|
||||||
}
|
|
||||||
|
|
||||||
if value := table.Data[2].Get("Key"); value != "C" {
|
|
||||||
t.Fatalf("Expected C, got %s", value)
|
|
||||||
}
|
|
||||||
|
|
||||||
if value := table.Data[3].Get("Key"); value != "D" {
|
|
||||||
t.Fatalf("Expected D, got %s", value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTableReverseSortStringValue(t *testing.T) {
|
|
||||||
table := NewTable("Key", 0)
|
|
||||||
|
|
||||||
e := &Env{}
|
|
||||||
e.Set("Key", "A")
|
|
||||||
table.Add(e)
|
|
||||||
|
|
||||||
e = &Env{}
|
|
||||||
e.Set("Key", "D")
|
|
||||||
table.Add(e)
|
|
||||||
|
|
||||||
e = &Env{}
|
|
||||||
e.Set("Key", "B")
|
|
||||||
table.Add(e)
|
|
||||||
|
|
||||||
e = &Env{}
|
|
||||||
e.Set("Key", "C")
|
|
||||||
table.Add(e)
|
|
||||||
|
|
||||||
table.ReverseSort()
|
|
||||||
|
|
||||||
if len := table.Len(); len != 4 {
|
|
||||||
t.Fatalf("Expected 4, got %d", len)
|
|
||||||
}
|
|
||||||
|
|
||||||
if value := table.Data[0].Get("Key"); value != "D" {
|
|
||||||
t.Fatalf("Expected D, got %s", value)
|
|
||||||
}
|
|
||||||
|
|
||||||
if value := table.Data[1].Get("Key"); value != "C" {
|
|
||||||
t.Fatalf("Expected B, got %s", value)
|
|
||||||
}
|
|
||||||
|
|
||||||
if value := table.Data[2].Get("Key"); value != "B" {
|
|
||||||
t.Fatalf("Expected C, got %s", value)
|
|
||||||
}
|
|
||||||
|
|
||||||
if value := table.Data[3].Get("Key"); value != "A" {
|
|
||||||
t.Fatalf("Expected A, got %s", value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,2 +0,0 @@
|
||||||
Cristian Staretu <cristian.staretu@gmail.com> (@unclejack)
|
|
||||||
Tibor Vass <teabee89@gmail.com> (@tiborvass)
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
This code provides helper functions for dealing with archive files.
|
|
||||||
|
|
@ -1,817 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"bytes"
|
|
||||||
"compress/bzip2"
|
|
||||||
"compress/gzip"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"os/exec"
|
|
||||||
"path"
|
|
||||||
"path/filepath"
|
|
||||||
"strings"
|
|
||||||
"syscall"
|
|
||||||
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
|
|
||||||
log "github.com/Sirupsen/logrus"
|
|
||||||
"github.com/docker/docker/pkg/fileutils"
|
|
||||||
"github.com/docker/docker/pkg/pools"
|
|
||||||
"github.com/docker/docker/pkg/promise"
|
|
||||||
"github.com/docker/docker/pkg/system"
|
|
||||||
)
|
|
||||||
|
|
||||||
type (
|
|
||||||
Archive io.ReadCloser
|
|
||||||
ArchiveReader io.Reader
|
|
||||||
Compression int
|
|
||||||
TarOptions struct {
|
|
||||||
IncludeFiles []string
|
|
||||||
ExcludePatterns []string
|
|
||||||
Compression Compression
|
|
||||||
NoLchown bool
|
|
||||||
Name string
|
|
||||||
}
|
|
||||||
|
|
||||||
// Archiver allows the reuse of most utility functions of this package
|
|
||||||
// with a pluggable Untar function.
|
|
||||||
Archiver struct {
|
|
||||||
Untar func(io.Reader, string, *TarOptions) error
|
|
||||||
}
|
|
||||||
|
|
||||||
// breakoutError is used to differentiate errors related to breaking out
|
|
||||||
// When testing archive breakout in the unit tests, this error is expected
|
|
||||||
// in order for the test to pass.
|
|
||||||
breakoutError error
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
ErrNotImplemented = errors.New("Function not implemented")
|
|
||||||
defaultArchiver = &Archiver{Untar}
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
Uncompressed Compression = iota
|
|
||||||
Bzip2
|
|
||||||
Gzip
|
|
||||||
Xz
|
|
||||||
)
|
|
||||||
|
|
||||||
func IsArchive(header []byte) bool {
|
|
||||||
compression := DetectCompression(header)
|
|
||||||
if compression != Uncompressed {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
r := tar.NewReader(bytes.NewBuffer(header))
|
|
||||||
_, err := r.Next()
|
|
||||||
return err == nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func DetectCompression(source []byte) Compression {
|
|
||||||
for compression, m := range map[Compression][]byte{
|
|
||||||
Bzip2: {0x42, 0x5A, 0x68},
|
|
||||||
Gzip: {0x1F, 0x8B, 0x08},
|
|
||||||
Xz: {0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00},
|
|
||||||
} {
|
|
||||||
if len(source) < len(m) {
|
|
||||||
log.Debugf("Len too short")
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if bytes.Compare(m, source[:len(m)]) == 0 {
|
|
||||||
return compression
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return Uncompressed
|
|
||||||
}
|
|
||||||
|
|
||||||
func xzDecompress(archive io.Reader) (io.ReadCloser, error) {
|
|
||||||
args := []string{"xz", "-d", "-c", "-q"}
|
|
||||||
|
|
||||||
return CmdStream(exec.Command(args[0], args[1:]...), archive)
|
|
||||||
}
|
|
||||||
|
|
||||||
func DecompressStream(archive io.Reader) (io.ReadCloser, error) {
|
|
||||||
p := pools.BufioReader32KPool
|
|
||||||
buf := p.Get(archive)
|
|
||||||
bs, err := buf.Peek(10)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
compression := DetectCompression(bs)
|
|
||||||
switch compression {
|
|
||||||
case Uncompressed:
|
|
||||||
readBufWrapper := p.NewReadCloserWrapper(buf, buf)
|
|
||||||
return readBufWrapper, nil
|
|
||||||
case Gzip:
|
|
||||||
gzReader, err := gzip.NewReader(buf)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
readBufWrapper := p.NewReadCloserWrapper(buf, gzReader)
|
|
||||||
return readBufWrapper, nil
|
|
||||||
case Bzip2:
|
|
||||||
bz2Reader := bzip2.NewReader(buf)
|
|
||||||
readBufWrapper := p.NewReadCloserWrapper(buf, bz2Reader)
|
|
||||||
return readBufWrapper, nil
|
|
||||||
case Xz:
|
|
||||||
xzReader, err := xzDecompress(buf)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
readBufWrapper := p.NewReadCloserWrapper(buf, xzReader)
|
|
||||||
return readBufWrapper, nil
|
|
||||||
default:
|
|
||||||
return nil, fmt.Errorf("Unsupported compression format %s", (&compression).Extension())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func CompressStream(dest io.WriteCloser, compression Compression) (io.WriteCloser, error) {
|
|
||||||
p := pools.BufioWriter32KPool
|
|
||||||
buf := p.Get(dest)
|
|
||||||
switch compression {
|
|
||||||
case Uncompressed:
|
|
||||||
writeBufWrapper := p.NewWriteCloserWrapper(buf, buf)
|
|
||||||
return writeBufWrapper, nil
|
|
||||||
case Gzip:
|
|
||||||
gzWriter := gzip.NewWriter(dest)
|
|
||||||
writeBufWrapper := p.NewWriteCloserWrapper(buf, gzWriter)
|
|
||||||
return writeBufWrapper, nil
|
|
||||||
case Bzip2, Xz:
|
|
||||||
// archive/bzip2 does not support writing, and there is no xz support at all
|
|
||||||
// However, this is not a problem as docker only currently generates gzipped tars
|
|
||||||
return nil, fmt.Errorf("Unsupported compression format %s", (&compression).Extension())
|
|
||||||
default:
|
|
||||||
return nil, fmt.Errorf("Unsupported compression format %s", (&compression).Extension())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (compression *Compression) Extension() string {
|
|
||||||
switch *compression {
|
|
||||||
case Uncompressed:
|
|
||||||
return "tar"
|
|
||||||
case Bzip2:
|
|
||||||
return "tar.bz2"
|
|
||||||
case Gzip:
|
|
||||||
return "tar.gz"
|
|
||||||
case Xz:
|
|
||||||
return "tar.xz"
|
|
||||||
}
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
|
|
||||||
type tarAppender struct {
|
|
||||||
TarWriter *tar.Writer
|
|
||||||
Buffer *bufio.Writer
|
|
||||||
|
|
||||||
// for hardlink mapping
|
|
||||||
SeenFiles map[uint64]string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ta *tarAppender) addTarFile(path, name string) error {
|
|
||||||
fi, err := os.Lstat(path)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
link := ""
|
|
||||||
if fi.Mode()&os.ModeSymlink != 0 {
|
|
||||||
if link, err = os.Readlink(path); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
hdr, err := tar.FileInfoHeader(fi, link)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if fi.IsDir() && !strings.HasSuffix(name, "/") {
|
|
||||||
name = name + "/"
|
|
||||||
}
|
|
||||||
|
|
||||||
hdr.Name = name
|
|
||||||
|
|
||||||
nlink, inode, err := setHeaderForSpecialDevice(hdr, ta, name, fi.Sys())
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// if it's a regular file and has more than 1 link,
|
|
||||||
// it's hardlinked, so set the type flag accordingly
|
|
||||||
if fi.Mode().IsRegular() && nlink > 1 {
|
|
||||||
// a link should have a name that it links too
|
|
||||||
// and that linked name should be first in the tar archive
|
|
||||||
if oldpath, ok := ta.SeenFiles[inode]; ok {
|
|
||||||
hdr.Typeflag = tar.TypeLink
|
|
||||||
hdr.Linkname = oldpath
|
|
||||||
hdr.Size = 0 // This Must be here for the writer math to add up!
|
|
||||||
} else {
|
|
||||||
ta.SeenFiles[inode] = name
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
capability, _ := system.Lgetxattr(path, "security.capability")
|
|
||||||
if capability != nil {
|
|
||||||
hdr.Xattrs = make(map[string]string)
|
|
||||||
hdr.Xattrs["security.capability"] = string(capability)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := ta.TarWriter.WriteHeader(hdr); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if hdr.Typeflag == tar.TypeReg {
|
|
||||||
file, err := os.Open(path)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
ta.Buffer.Reset(ta.TarWriter)
|
|
||||||
defer ta.Buffer.Reset(nil)
|
|
||||||
_, err = io.Copy(ta.Buffer, file)
|
|
||||||
file.Close()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
err = ta.Buffer.Flush()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func createTarFile(path, extractDir string, hdr *tar.Header, reader io.Reader, Lchown bool) error {
|
|
||||||
// hdr.Mode is in linux format, which we can use for sycalls,
|
|
||||||
// but for os.Foo() calls we need the mode converted to os.FileMode,
|
|
||||||
// so use hdrInfo.Mode() (they differ for e.g. setuid bits)
|
|
||||||
hdrInfo := hdr.FileInfo()
|
|
||||||
|
|
||||||
switch hdr.Typeflag {
|
|
||||||
case tar.TypeDir:
|
|
||||||
// Create directory unless it exists as a directory already.
|
|
||||||
// In that case we just want to merge the two
|
|
||||||
if fi, err := os.Lstat(path); !(err == nil && fi.IsDir()) {
|
|
||||||
if err := os.Mkdir(path, hdrInfo.Mode()); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
case tar.TypeReg, tar.TypeRegA:
|
|
||||||
// Source is regular file
|
|
||||||
file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, hdrInfo.Mode())
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if _, err := io.Copy(file, reader); err != nil {
|
|
||||||
file.Close()
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
file.Close()
|
|
||||||
|
|
||||||
case tar.TypeBlock, tar.TypeChar, tar.TypeFifo:
|
|
||||||
mode := uint32(hdr.Mode & 07777)
|
|
||||||
switch hdr.Typeflag {
|
|
||||||
case tar.TypeBlock:
|
|
||||||
mode |= syscall.S_IFBLK
|
|
||||||
case tar.TypeChar:
|
|
||||||
mode |= syscall.S_IFCHR
|
|
||||||
case tar.TypeFifo:
|
|
||||||
mode |= syscall.S_IFIFO
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := system.Mknod(path, mode, int(system.Mkdev(hdr.Devmajor, hdr.Devminor))); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
case tar.TypeLink:
|
|
||||||
targetPath := filepath.Join(extractDir, hdr.Linkname)
|
|
||||||
// check for hardlink breakout
|
|
||||||
if !strings.HasPrefix(targetPath, extractDir) {
|
|
||||||
return breakoutError(fmt.Errorf("invalid hardlink %q -> %q", targetPath, hdr.Linkname))
|
|
||||||
}
|
|
||||||
if err := os.Link(targetPath, path); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
case tar.TypeSymlink:
|
|
||||||
// path -> hdr.Linkname = targetPath
|
|
||||||
// e.g. /extractDir/path/to/symlink -> ../2/file = /extractDir/path/2/file
|
|
||||||
targetPath := filepath.Join(filepath.Dir(path), hdr.Linkname)
|
|
||||||
|
|
||||||
// the reason we don't need to check symlinks in the path (with FollowSymlinkInScope) is because
|
|
||||||
// that symlink would first have to be created, which would be caught earlier, at this very check:
|
|
||||||
if !strings.HasPrefix(targetPath, extractDir) {
|
|
||||||
return breakoutError(fmt.Errorf("invalid symlink %q -> %q", path, hdr.Linkname))
|
|
||||||
}
|
|
||||||
if err := os.Symlink(hdr.Linkname, path); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
case tar.TypeXGlobalHeader:
|
|
||||||
log.Debugf("PAX Global Extended Headers found and ignored")
|
|
||||||
return nil
|
|
||||||
|
|
||||||
default:
|
|
||||||
return fmt.Errorf("Unhandled tar header type %d\n", hdr.Typeflag)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := os.Lchown(path, hdr.Uid, hdr.Gid); err != nil && Lchown {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
for key, value := range hdr.Xattrs {
|
|
||||||
if err := system.Lsetxattr(path, key, []byte(value), 0); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// There is no LChmod, so ignore mode for symlink. Also, this
|
|
||||||
// must happen after chown, as that can modify the file mode
|
|
||||||
if hdr.Typeflag != tar.TypeSymlink {
|
|
||||||
if err := os.Chmod(path, hdrInfo.Mode()); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ts := []syscall.Timespec{timeToTimespec(hdr.AccessTime), timeToTimespec(hdr.ModTime)}
|
|
||||||
// syscall.UtimesNano doesn't support a NOFOLLOW flag atm, and
|
|
||||||
if hdr.Typeflag != tar.TypeSymlink {
|
|
||||||
if err := system.UtimesNano(path, ts); err != nil && err != system.ErrNotSupportedPlatform {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if err := system.LUtimesNano(path, ts); err != nil && err != system.ErrNotSupportedPlatform {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Tar creates an archive from the directory at `path`, and returns it as a
|
|
||||||
// stream of bytes.
|
|
||||||
func Tar(path string, compression Compression) (io.ReadCloser, error) {
|
|
||||||
return TarWithOptions(path, &TarOptions{Compression: compression})
|
|
||||||
}
|
|
||||||
|
|
||||||
func escapeName(name string) string {
|
|
||||||
escaped := make([]byte, 0)
|
|
||||||
for i, c := range []byte(name) {
|
|
||||||
if i == 0 && c == '/' {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
// all printable chars except "-" which is 0x2d
|
|
||||||
if (0x20 <= c && c <= 0x7E) && c != 0x2d {
|
|
||||||
escaped = append(escaped, c)
|
|
||||||
} else {
|
|
||||||
escaped = append(escaped, fmt.Sprintf("\\%03o", c)...)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return string(escaped)
|
|
||||||
}
|
|
||||||
|
|
||||||
// TarWithOptions creates an archive from the directory at `path`, only including files whose relative
|
|
||||||
// paths are included in `options.IncludeFiles` (if non-nil) or not in `options.ExcludePatterns`.
|
|
||||||
func TarWithOptions(srcPath string, options *TarOptions) (io.ReadCloser, error) {
|
|
||||||
pipeReader, pipeWriter := io.Pipe()
|
|
||||||
|
|
||||||
compressWriter, err := CompressStream(pipeWriter, options.Compression)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
go func() {
|
|
||||||
ta := &tarAppender{
|
|
||||||
TarWriter: tar.NewWriter(compressWriter),
|
|
||||||
Buffer: pools.BufioWriter32KPool.Get(nil),
|
|
||||||
SeenFiles: make(map[uint64]string),
|
|
||||||
}
|
|
||||||
// this buffer is needed for the duration of this piped stream
|
|
||||||
defer pools.BufioWriter32KPool.Put(ta.Buffer)
|
|
||||||
|
|
||||||
// In general we log errors here but ignore them because
|
|
||||||
// during e.g. a diff operation the container can continue
|
|
||||||
// mutating the filesystem and we can see transient errors
|
|
||||||
// from this
|
|
||||||
|
|
||||||
if options.IncludeFiles == nil {
|
|
||||||
options.IncludeFiles = []string{"."}
|
|
||||||
}
|
|
||||||
|
|
||||||
seen := make(map[string]bool)
|
|
||||||
|
|
||||||
var renamedRelFilePath string // For when tar.Options.Name is set
|
|
||||||
for _, include := range options.IncludeFiles {
|
|
||||||
filepath.Walk(filepath.Join(srcPath, include), func(filePath string, f os.FileInfo, err error) error {
|
|
||||||
if err != nil {
|
|
||||||
log.Debugf("Tar: Can't stat file %s to tar: %s", srcPath, err)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
relFilePath, err := filepath.Rel(srcPath, filePath)
|
|
||||||
if err != nil || (relFilePath == "." && f.IsDir()) {
|
|
||||||
// Error getting relative path OR we are looking
|
|
||||||
// at the root path. Skip in both situations.
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
skip := false
|
|
||||||
|
|
||||||
// If "include" is an exact match for the current file
|
|
||||||
// then even if there's an "excludePatterns" pattern that
|
|
||||||
// matches it, don't skip it. IOW, assume an explicit 'include'
|
|
||||||
// is asking for that file no matter what - which is true
|
|
||||||
// for some files, like .dockerignore and Dockerfile (sometimes)
|
|
||||||
if include != relFilePath {
|
|
||||||
skip, err = fileutils.Matches(relFilePath, options.ExcludePatterns)
|
|
||||||
if err != nil {
|
|
||||||
log.Debugf("Error matching %s", relFilePath, err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if skip {
|
|
||||||
if f.IsDir() {
|
|
||||||
return filepath.SkipDir
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if seen[relFilePath] {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
seen[relFilePath] = true
|
|
||||||
|
|
||||||
// Rename the base resource
|
|
||||||
if options.Name != "" && filePath == srcPath+"/"+filepath.Base(relFilePath) {
|
|
||||||
renamedRelFilePath = relFilePath
|
|
||||||
}
|
|
||||||
// Set this to make sure the items underneath also get renamed
|
|
||||||
if options.Name != "" {
|
|
||||||
relFilePath = strings.Replace(relFilePath, renamedRelFilePath, options.Name, 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := ta.addTarFile(filePath, relFilePath); err != nil {
|
|
||||||
log.Debugf("Can't add file %s to tar: %s", srcPath, err)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// Make sure to check the error on Close.
|
|
||||||
if err := ta.TarWriter.Close(); err != nil {
|
|
||||||
log.Debugf("Can't close tar writer: %s", err)
|
|
||||||
}
|
|
||||||
if err := compressWriter.Close(); err != nil {
|
|
||||||
log.Debugf("Can't close compress writer: %s", err)
|
|
||||||
}
|
|
||||||
if err := pipeWriter.Close(); err != nil {
|
|
||||||
log.Debugf("Can't close pipe writer: %s", err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
|
|
||||||
return pipeReader, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func Unpack(decompressedArchive io.Reader, dest string, options *TarOptions) error {
|
|
||||||
tr := tar.NewReader(decompressedArchive)
|
|
||||||
trBuf := pools.BufioReader32KPool.Get(nil)
|
|
||||||
defer pools.BufioReader32KPool.Put(trBuf)
|
|
||||||
|
|
||||||
var dirs []*tar.Header
|
|
||||||
|
|
||||||
// Iterate through the files in the archive.
|
|
||||||
loop:
|
|
||||||
for {
|
|
||||||
hdr, err := tr.Next()
|
|
||||||
if err == io.EOF {
|
|
||||||
// end of tar archive
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Normalize name, for safety and for a simple is-root check
|
|
||||||
// This keeps "../" as-is, but normalizes "/../" to "/"
|
|
||||||
hdr.Name = filepath.Clean(hdr.Name)
|
|
||||||
|
|
||||||
for _, exclude := range options.ExcludePatterns {
|
|
||||||
if strings.HasPrefix(hdr.Name, exclude) {
|
|
||||||
continue loop
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if !strings.HasSuffix(hdr.Name, "/") {
|
|
||||||
// Not the root directory, ensure that the parent directory exists
|
|
||||||
parent := filepath.Dir(hdr.Name)
|
|
||||||
parentPath := filepath.Join(dest, parent)
|
|
||||||
if _, err := os.Lstat(parentPath); err != nil && os.IsNotExist(err) {
|
|
||||||
err = os.MkdirAll(parentPath, 0777)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
path := filepath.Join(dest, hdr.Name)
|
|
||||||
rel, err := filepath.Rel(dest, path)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if strings.HasPrefix(rel, "..") {
|
|
||||||
return breakoutError(fmt.Errorf("%q is outside of %q", hdr.Name, dest))
|
|
||||||
}
|
|
||||||
|
|
||||||
// If path exits we almost always just want to remove and replace it
|
|
||||||
// The only exception is when it is a directory *and* the file from
|
|
||||||
// the layer is also a directory. Then we want to merge them (i.e.
|
|
||||||
// just apply the metadata from the layer).
|
|
||||||
if fi, err := os.Lstat(path); err == nil {
|
|
||||||
if fi.IsDir() && hdr.Name == "." {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if !(fi.IsDir() && hdr.Typeflag == tar.TypeDir) {
|
|
||||||
if err := os.RemoveAll(path); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
trBuf.Reset(tr)
|
|
||||||
if err := createTarFile(path, dest, hdr, trBuf, !options.NoLchown); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Directory mtimes must be handled at the end to avoid further
|
|
||||||
// file creation in them to modify the directory mtime
|
|
||||||
if hdr.Typeflag == tar.TypeDir {
|
|
||||||
dirs = append(dirs, hdr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, hdr := range dirs {
|
|
||||||
path := filepath.Join(dest, hdr.Name)
|
|
||||||
ts := []syscall.Timespec{timeToTimespec(hdr.AccessTime), timeToTimespec(hdr.ModTime)}
|
|
||||||
if err := syscall.UtimesNano(path, ts); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Untar reads a stream of bytes from `archive`, parses it as a tar archive,
|
|
||||||
// and unpacks it into the directory at `dest`.
|
|
||||||
// The archive may be compressed with one of the following algorithms:
|
|
||||||
// identity (uncompressed), gzip, bzip2, xz.
|
|
||||||
// FIXME: specify behavior when target path exists vs. doesn't exist.
|
|
||||||
func Untar(archive io.Reader, dest string, options *TarOptions) error {
|
|
||||||
if archive == nil {
|
|
||||||
return fmt.Errorf("Empty archive")
|
|
||||||
}
|
|
||||||
dest = filepath.Clean(dest)
|
|
||||||
if options == nil {
|
|
||||||
options = &TarOptions{}
|
|
||||||
}
|
|
||||||
if options.ExcludePatterns == nil {
|
|
||||||
options.ExcludePatterns = []string{}
|
|
||||||
}
|
|
||||||
decompressedArchive, err := DecompressStream(archive)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer decompressedArchive.Close()
|
|
||||||
return Unpack(decompressedArchive, dest, options)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (archiver *Archiver) TarUntar(src, dst string) error {
|
|
||||||
log.Debugf("TarUntar(%s %s)", src, dst)
|
|
||||||
archive, err := TarWithOptions(src, &TarOptions{Compression: Uncompressed})
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer archive.Close()
|
|
||||||
return archiver.Untar(archive, dst, nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
// TarUntar is a convenience function which calls Tar and Untar, with the output of one piped into the other.
|
|
||||||
// If either Tar or Untar fails, TarUntar aborts and returns the error.
|
|
||||||
func TarUntar(src, dst string) error {
|
|
||||||
return defaultArchiver.TarUntar(src, dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (archiver *Archiver) UntarPath(src, dst string) error {
|
|
||||||
archive, err := os.Open(src)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer archive.Close()
|
|
||||||
if err := archiver.Untar(archive, dst, nil); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// UntarPath is a convenience function which looks for an archive
|
|
||||||
// at filesystem path `src`, and unpacks it at `dst`.
|
|
||||||
func UntarPath(src, dst string) error {
|
|
||||||
return defaultArchiver.UntarPath(src, dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (archiver *Archiver) CopyWithTar(src, dst string) error {
|
|
||||||
srcSt, err := os.Stat(src)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if !srcSt.IsDir() {
|
|
||||||
return archiver.CopyFileWithTar(src, dst)
|
|
||||||
}
|
|
||||||
// Create dst, copy src's content into it
|
|
||||||
log.Debugf("Creating dest directory: %s", dst)
|
|
||||||
if err := os.MkdirAll(dst, 0755); err != nil && !os.IsExist(err) {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
log.Debugf("Calling TarUntar(%s, %s)", src, dst)
|
|
||||||
return archiver.TarUntar(src, dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
// CopyWithTar creates a tar archive of filesystem path `src`, and
|
|
||||||
// unpacks it at filesystem path `dst`.
|
|
||||||
// The archive is streamed directly with fixed buffering and no
|
|
||||||
// intermediary disk IO.
|
|
||||||
func CopyWithTar(src, dst string) error {
|
|
||||||
return defaultArchiver.CopyWithTar(src, dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (archiver *Archiver) CopyFileWithTar(src, dst string) (err error) {
|
|
||||||
log.Debugf("CopyFileWithTar(%s, %s)", src, dst)
|
|
||||||
srcSt, err := os.Stat(src)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if srcSt.IsDir() {
|
|
||||||
return fmt.Errorf("Can't copy a directory")
|
|
||||||
}
|
|
||||||
// Clean up the trailing /
|
|
||||||
if dst[len(dst)-1] == '/' {
|
|
||||||
dst = path.Join(dst, filepath.Base(src))
|
|
||||||
}
|
|
||||||
// Create the holding directory if necessary
|
|
||||||
if err := os.MkdirAll(filepath.Dir(dst), 0700); err != nil && !os.IsExist(err) {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
r, w := io.Pipe()
|
|
||||||
errC := promise.Go(func() error {
|
|
||||||
defer w.Close()
|
|
||||||
|
|
||||||
srcF, err := os.Open(src)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer srcF.Close()
|
|
||||||
|
|
||||||
hdr, err := tar.FileInfoHeader(srcSt, "")
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
hdr.Name = filepath.Base(dst)
|
|
||||||
tw := tar.NewWriter(w)
|
|
||||||
defer tw.Close()
|
|
||||||
if err := tw.WriteHeader(hdr); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if _, err := io.Copy(tw, srcF); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
defer func() {
|
|
||||||
if er := <-errC; err != nil {
|
|
||||||
err = er
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
return archiver.Untar(r, filepath.Dir(dst), nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
// CopyFileWithTar emulates the behavior of the 'cp' command-line
|
|
||||||
// for a single file. It copies a regular file from path `src` to
|
|
||||||
// path `dst`, and preserves all its metadata.
|
|
||||||
//
|
|
||||||
// If `dst` ends with a trailing slash '/', the final destination path
|
|
||||||
// will be `dst/base(src)`.
|
|
||||||
func CopyFileWithTar(src, dst string) (err error) {
|
|
||||||
return defaultArchiver.CopyFileWithTar(src, dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
// CmdStream executes a command, and returns its stdout as a stream.
|
|
||||||
// If the command fails to run or doesn't complete successfully, an error
|
|
||||||
// will be returned, including anything written on stderr.
|
|
||||||
func CmdStream(cmd *exec.Cmd, input io.Reader) (io.ReadCloser, error) {
|
|
||||||
if input != nil {
|
|
||||||
stdin, err := cmd.StdinPipe()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
// Write stdin if any
|
|
||||||
go func() {
|
|
||||||
io.Copy(stdin, input)
|
|
||||||
stdin.Close()
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
stdout, err := cmd.StdoutPipe()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
stderr, err := cmd.StderrPipe()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
pipeR, pipeW := io.Pipe()
|
|
||||||
errChan := make(chan []byte)
|
|
||||||
// Collect stderr, we will use it in case of an error
|
|
||||||
go func() {
|
|
||||||
errText, e := ioutil.ReadAll(stderr)
|
|
||||||
if e != nil {
|
|
||||||
errText = []byte("(...couldn't fetch stderr: " + e.Error() + ")")
|
|
||||||
}
|
|
||||||
errChan <- errText
|
|
||||||
}()
|
|
||||||
// Copy stdout to the returned pipe
|
|
||||||
go func() {
|
|
||||||
_, err := io.Copy(pipeW, stdout)
|
|
||||||
if err != nil {
|
|
||||||
pipeW.CloseWithError(err)
|
|
||||||
}
|
|
||||||
errText := <-errChan
|
|
||||||
if err := cmd.Wait(); err != nil {
|
|
||||||
pipeW.CloseWithError(fmt.Errorf("%s: %s", err, errText))
|
|
||||||
} else {
|
|
||||||
pipeW.Close()
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
// Run the command and return the pipe
|
|
||||||
if err := cmd.Start(); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return pipeR, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewTempArchive reads the content of src into a temporary file, and returns the contents
|
|
||||||
// of that file as an archive. The archive can only be read once - as soon as reading completes,
|
|
||||||
// the file will be deleted.
|
|
||||||
func NewTempArchive(src Archive, dir string) (*TempArchive, error) {
|
|
||||||
f, err := ioutil.TempFile(dir, "")
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
if _, err := io.Copy(f, src); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
if err = f.Sync(); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
if _, err := f.Seek(0, 0); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
st, err := f.Stat()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
size := st.Size()
|
|
||||||
return &TempArchive{File: f, Size: size}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
type TempArchive struct {
|
|
||||||
*os.File
|
|
||||||
Size int64 // Pre-computed from Stat().Size() as a convenience
|
|
||||||
read int64
|
|
||||||
closed bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close closes the underlying file if it's still open, or does a no-op
|
|
||||||
// to allow callers to try to close the TempArchive multiple times safely.
|
|
||||||
func (archive *TempArchive) Close() error {
|
|
||||||
if archive.closed {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
archive.closed = true
|
|
||||||
|
|
||||||
return archive.File.Close()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (archive *TempArchive) Read(data []byte) (int, error) {
|
|
||||||
n, err := archive.File.Read(data)
|
|
||||||
archive.read += int64(n)
|
|
||||||
if err != nil || archive.read == archive.Size {
|
|
||||||
archive.Close()
|
|
||||||
os.Remove(archive.File.Name())
|
|
||||||
}
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
|
|
@ -1,625 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"os/exec"
|
|
||||||
"path"
|
|
||||||
"path/filepath"
|
|
||||||
"strings"
|
|
||||||
"syscall"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestCmdStreamLargeStderr(t *testing.T) {
|
|
||||||
cmd := exec.Command("/bin/sh", "-c", "dd if=/dev/zero bs=1k count=1000 of=/dev/stderr; echo hello")
|
|
||||||
out, err := CmdStream(cmd, nil)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Failed to start command: %s", err)
|
|
||||||
}
|
|
||||||
errCh := make(chan error)
|
|
||||||
go func() {
|
|
||||||
_, err := io.Copy(ioutil.Discard, out)
|
|
||||||
errCh <- err
|
|
||||||
}()
|
|
||||||
select {
|
|
||||||
case err := <-errCh:
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Command should not have failed (err=%.100s...)", err)
|
|
||||||
}
|
|
||||||
case <-time.After(5 * time.Second):
|
|
||||||
t.Fatalf("Command did not complete in 5 seconds; probable deadlock")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCmdStreamBad(t *testing.T) {
|
|
||||||
badCmd := exec.Command("/bin/sh", "-c", "echo hello; echo >&2 error couldn\\'t reverse the phase pulser; exit 1")
|
|
||||||
out, err := CmdStream(badCmd, nil)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Failed to start command: %s", err)
|
|
||||||
}
|
|
||||||
if output, err := ioutil.ReadAll(out); err == nil {
|
|
||||||
t.Fatalf("Command should have failed")
|
|
||||||
} else if err.Error() != "exit status 1: error couldn't reverse the phase pulser\n" {
|
|
||||||
t.Fatalf("Wrong error value (%s)", err)
|
|
||||||
} else if s := string(output); s != "hello\n" {
|
|
||||||
t.Fatalf("Command output should be '%s', not '%s'", "hello\\n", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCmdStreamGood(t *testing.T) {
|
|
||||||
cmd := exec.Command("/bin/sh", "-c", "echo hello; exit 0")
|
|
||||||
out, err := CmdStream(cmd, nil)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if output, err := ioutil.ReadAll(out); err != nil {
|
|
||||||
t.Fatalf("Command should not have failed (err=%s)", err)
|
|
||||||
} else if s := string(output); s != "hello\n" {
|
|
||||||
t.Fatalf("Command output should be '%s', not '%s'", "hello\\n", output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTarFiles(t *testing.T) {
|
|
||||||
// try without hardlinks
|
|
||||||
if err := checkNoChanges(1000, false); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
// try with hardlinks
|
|
||||||
if err := checkNoChanges(1000, true); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkNoChanges(fileNum int, hardlinks bool) error {
|
|
||||||
srcDir, err := ioutil.TempDir("", "docker-test-srcDir")
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(srcDir)
|
|
||||||
|
|
||||||
destDir, err := ioutil.TempDir("", "docker-test-destDir")
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(destDir)
|
|
||||||
|
|
||||||
_, err = prepareUntarSourceDirectory(fileNum, srcDir, hardlinks)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
err = TarUntar(srcDir, destDir)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
changes, err := ChangesDirs(destDir, srcDir)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if len(changes) > 0 {
|
|
||||||
return fmt.Errorf("with %d files and %v hardlinks: expected 0 changes, got %d", fileNum, hardlinks, len(changes))
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func tarUntar(t *testing.T, origin string, options *TarOptions) ([]Change, error) {
|
|
||||||
archive, err := TarWithOptions(origin, options)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
defer archive.Close()
|
|
||||||
|
|
||||||
buf := make([]byte, 10)
|
|
||||||
if _, err := archive.Read(buf); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
wrap := io.MultiReader(bytes.NewReader(buf), archive)
|
|
||||||
|
|
||||||
detectedCompression := DetectCompression(buf)
|
|
||||||
compression := options.Compression
|
|
||||||
if detectedCompression.Extension() != compression.Extension() {
|
|
||||||
return nil, fmt.Errorf("Wrong compression detected. Actual compression: %s, found %s", compression.Extension(), detectedCompression.Extension())
|
|
||||||
}
|
|
||||||
|
|
||||||
tmp, err := ioutil.TempDir("", "docker-test-untar")
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(tmp)
|
|
||||||
if err := Untar(wrap, tmp, nil); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
if _, err := os.Stat(tmp); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
return ChangesDirs(origin, tmp)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTarUntar(t *testing.T) {
|
|
||||||
origin, err := ioutil.TempDir("", "docker-test-untar-origin")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(origin)
|
|
||||||
if err := ioutil.WriteFile(path.Join(origin, "1"), []byte("hello world"), 0700); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := ioutil.WriteFile(path.Join(origin, "2"), []byte("welcome!"), 0700); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := ioutil.WriteFile(path.Join(origin, "3"), []byte("will be ignored"), 0700); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, c := range []Compression{
|
|
||||||
Uncompressed,
|
|
||||||
Gzip,
|
|
||||||
} {
|
|
||||||
changes, err := tarUntar(t, origin, &TarOptions{
|
|
||||||
Compression: c,
|
|
||||||
ExcludePatterns: []string{"3"},
|
|
||||||
})
|
|
||||||
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Error tar/untar for compression %s: %s", c.Extension(), err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(changes) != 1 || changes[0].Path != "/3" {
|
|
||||||
t.Fatalf("Unexpected differences after tarUntar: %v", changes)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTarWithOptions(t *testing.T) {
|
|
||||||
origin, err := ioutil.TempDir("", "docker-test-untar-origin")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(origin)
|
|
||||||
if err := ioutil.WriteFile(path.Join(origin, "1"), []byte("hello world"), 0700); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := ioutil.WriteFile(path.Join(origin, "2"), []byte("welcome!"), 0700); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
cases := []struct {
|
|
||||||
opts *TarOptions
|
|
||||||
numChanges int
|
|
||||||
}{
|
|
||||||
{&TarOptions{IncludeFiles: []string{"1"}}, 1},
|
|
||||||
{&TarOptions{ExcludePatterns: []string{"2"}}, 1},
|
|
||||||
}
|
|
||||||
for _, testCase := range cases {
|
|
||||||
changes, err := tarUntar(t, origin, testCase.opts)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Error tar/untar when testing inclusion/exclusion: %s", err)
|
|
||||||
}
|
|
||||||
if len(changes) != testCase.numChanges {
|
|
||||||
t.Errorf("Expected %d changes, got %d for %+v:",
|
|
||||||
testCase.numChanges, len(changes), testCase.opts)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Some tar archives such as http://haproxy.1wt.eu/download/1.5/src/devel/haproxy-1.5-dev21.tar.gz
|
|
||||||
// use PAX Global Extended Headers.
|
|
||||||
// Failing prevents the archives from being uncompressed during ADD
|
|
||||||
func TestTypeXGlobalHeaderDoesNotFail(t *testing.T) {
|
|
||||||
hdr := tar.Header{Typeflag: tar.TypeXGlobalHeader}
|
|
||||||
tmpDir, err := ioutil.TempDir("", "docker-test-archive-pax-test")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(tmpDir)
|
|
||||||
err = createTarFile(filepath.Join(tmpDir, "pax_global_header"), tmpDir, &hdr, nil, true)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Some tar have both GNU specific (huge uid) and Ustar specific (long name) things.
|
|
||||||
// Not supposed to happen (should use PAX instead of Ustar for long name) but it does and it should still work.
|
|
||||||
func TestUntarUstarGnuConflict(t *testing.T) {
|
|
||||||
f, err := os.Open("testdata/broken.tar")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
found := false
|
|
||||||
tr := tar.NewReader(f)
|
|
||||||
// Iterate through the files in the archive.
|
|
||||||
for {
|
|
||||||
hdr, err := tr.Next()
|
|
||||||
if err == io.EOF {
|
|
||||||
// end of tar archive
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if hdr.Name == "root/.cpanm/work/1395823785.24209/Plack-1.0030/blib/man3/Plack::Middleware::LighttpdScriptNameFix.3pm" {
|
|
||||||
found = true
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if !found {
|
|
||||||
t.Fatalf("%s not found in the archive", "root/.cpanm/work/1395823785.24209/Plack-1.0030/blib/man3/Plack::Middleware::LighttpdScriptNameFix.3pm")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTarWithHardLink(t *testing.T) {
|
|
||||||
origin, err := ioutil.TempDir("", "docker-test-tar-hardlink")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(origin)
|
|
||||||
if err := ioutil.WriteFile(path.Join(origin, "1"), []byte("hello world"), 0700); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := os.Link(path.Join(origin, "1"), path.Join(origin, "2")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
var i1, i2 uint64
|
|
||||||
if i1, err = getNlink(path.Join(origin, "1")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
// sanity check that we can hardlink
|
|
||||||
if i1 != 2 {
|
|
||||||
t.Skipf("skipping since hardlinks don't work here; expected 2 links, got %d", i1)
|
|
||||||
}
|
|
||||||
|
|
||||||
dest, err := ioutil.TempDir("", "docker-test-tar-hardlink-dest")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(dest)
|
|
||||||
|
|
||||||
// we'll do this in two steps to separate failure
|
|
||||||
fh, err := Tar(origin, Uncompressed)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// ensure we can read the whole thing with no error, before writing back out
|
|
||||||
buf, err := ioutil.ReadAll(fh)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
bRdr := bytes.NewReader(buf)
|
|
||||||
err = Untar(bRdr, dest, &TarOptions{Compression: Uncompressed})
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if i1, err = getInode(path.Join(dest, "1")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if i2, err = getInode(path.Join(dest, "2")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if i1 != i2 {
|
|
||||||
t.Errorf("expected matching inodes, but got %d and %d", i1, i2)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func getNlink(path string) (uint64, error) {
|
|
||||||
stat, err := os.Stat(path)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
statT, ok := stat.Sys().(*syscall.Stat_t)
|
|
||||||
if !ok {
|
|
||||||
return 0, fmt.Errorf("expected type *syscall.Stat_t, got %t", stat.Sys())
|
|
||||||
}
|
|
||||||
return statT.Nlink, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func getInode(path string) (uint64, error) {
|
|
||||||
stat, err := os.Stat(path)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
statT, ok := stat.Sys().(*syscall.Stat_t)
|
|
||||||
if !ok {
|
|
||||||
return 0, fmt.Errorf("expected type *syscall.Stat_t, got %t", stat.Sys())
|
|
||||||
}
|
|
||||||
return statT.Ino, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func prepareUntarSourceDirectory(numberOfFiles int, targetPath string, makeLinks bool) (int, error) {
|
|
||||||
fileData := []byte("fooo")
|
|
||||||
for n := 0; n < numberOfFiles; n++ {
|
|
||||||
fileName := fmt.Sprintf("file-%d", n)
|
|
||||||
if err := ioutil.WriteFile(path.Join(targetPath, fileName), fileData, 0700); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
if makeLinks {
|
|
||||||
if err := os.Link(path.Join(targetPath, fileName), path.Join(targetPath, fileName+"-link")); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
totalSize := numberOfFiles * len(fileData)
|
|
||||||
return totalSize, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkTarUntar(b *testing.B) {
|
|
||||||
origin, err := ioutil.TempDir("", "docker-test-untar-origin")
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
tempDir, err := ioutil.TempDir("", "docker-test-untar-destination")
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
target := path.Join(tempDir, "dest")
|
|
||||||
n, err := prepareUntarSourceDirectory(100, origin, false)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(origin)
|
|
||||||
defer os.RemoveAll(tempDir)
|
|
||||||
|
|
||||||
b.ResetTimer()
|
|
||||||
b.SetBytes(int64(n))
|
|
||||||
for n := 0; n < b.N; n++ {
|
|
||||||
err := TarUntar(origin, target)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
os.RemoveAll(target)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkTarUntarWithLinks(b *testing.B) {
|
|
||||||
origin, err := ioutil.TempDir("", "docker-test-untar-origin")
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
tempDir, err := ioutil.TempDir("", "docker-test-untar-destination")
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
target := path.Join(tempDir, "dest")
|
|
||||||
n, err := prepareUntarSourceDirectory(100, origin, true)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(origin)
|
|
||||||
defer os.RemoveAll(tempDir)
|
|
||||||
|
|
||||||
b.ResetTimer()
|
|
||||||
b.SetBytes(int64(n))
|
|
||||||
for n := 0; n < b.N; n++ {
|
|
||||||
err := TarUntar(origin, target)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
os.RemoveAll(target)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestUntarInvalidFilenames(t *testing.T) {
|
|
||||||
for i, headers := range [][]*tar.Header{
|
|
||||||
{
|
|
||||||
{
|
|
||||||
Name: "../victim/dotdot",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{
|
|
||||||
{
|
|
||||||
// Note the leading slash
|
|
||||||
Name: "/../victim/slash-dotdot",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
} {
|
|
||||||
if err := testBreakout("untar", "docker-TestUntarInvalidFilenames", headers); err != nil {
|
|
||||||
t.Fatalf("i=%d. %v", i, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestUntarInvalidHardlink(t *testing.T) {
|
|
||||||
for i, headers := range [][]*tar.Header{
|
|
||||||
{ // try reading victim/hello (../)
|
|
||||||
{
|
|
||||||
Name: "dotdot",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (/../)
|
|
||||||
{
|
|
||||||
Name: "slash-dotdot",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
// Note the leading slash
|
|
||||||
Linkname: "/../victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try writing victim/file
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "loophole-victim/file",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (hardlink, symlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "symlink",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "loophole-victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // Try reading victim/hello (hardlink, hardlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "hardlink",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "loophole-victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // Try removing victim directory (hardlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
} {
|
|
||||||
if err := testBreakout("untar", "docker-TestUntarInvalidHardlink", headers); err != nil {
|
|
||||||
t.Fatalf("i=%d. %v", i, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestUntarInvalidSymlink(t *testing.T) {
|
|
||||||
for i, headers := range [][]*tar.Header{
|
|
||||||
{ // try reading victim/hello (../)
|
|
||||||
{
|
|
||||||
Name: "dotdot",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (/../)
|
|
||||||
{
|
|
||||||
Name: "slash-dotdot",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
// Note the leading slash
|
|
||||||
Linkname: "/../victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try writing victim/file
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "loophole-victim/file",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (symlink, symlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "symlink",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "loophole-victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (symlink, hardlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "hardlink",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "loophole-victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try removing victim directory (symlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try writing to victim/newdir/newfile with a symlink in the path
|
|
||||||
{
|
|
||||||
// this header needs to be before the next one, or else there is an error
|
|
||||||
Name: "dir/loophole",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "dir/loophole/newdir/newfile",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
} {
|
|
||||||
if err := testBreakout("untar", "docker-TestUntarInvalidSymlink", headers); err != nil {
|
|
||||||
t.Fatalf("i=%d. %v", i, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTempArchiveCloseMultipleTimes(t *testing.T) {
|
|
||||||
reader := ioutil.NopCloser(strings.NewReader("hello"))
|
|
||||||
tempArchive, err := NewTempArchive(reader, "")
|
|
||||||
buf := make([]byte, 10)
|
|
||||||
n, err := tempArchive.Read(buf)
|
|
||||||
if n != 5 {
|
|
||||||
t.Fatalf("Expected to read 5 bytes. Read %d instead", n)
|
|
||||||
}
|
|
||||||
for i := 0; i < 3; i++ {
|
|
||||||
if err = tempArchive.Close(); err != nil {
|
|
||||||
t.Fatalf("i=%d. Unexpected error closing temp archive: %v", i, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,39 +0,0 @@
|
||||||
// +build !windows
|
|
||||||
|
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"syscall"
|
|
||||||
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
)
|
|
||||||
|
|
||||||
func setHeaderForSpecialDevice(hdr *tar.Header, ta *tarAppender, name string, stat interface{}) (nlink uint32, inode uint64, err error) {
|
|
||||||
s, ok := stat.(*syscall.Stat_t)
|
|
||||||
|
|
||||||
if !ok {
|
|
||||||
err = errors.New("cannot convert stat value to syscall.Stat_t")
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
nlink = uint32(s.Nlink)
|
|
||||||
inode = uint64(s.Ino)
|
|
||||||
|
|
||||||
// Currently go does not fil in the major/minors
|
|
||||||
if s.Mode&syscall.S_IFBLK == syscall.S_IFBLK ||
|
|
||||||
s.Mode&syscall.S_IFCHR == syscall.S_IFCHR {
|
|
||||||
hdr.Devmajor = int64(major(uint64(s.Rdev)))
|
|
||||||
hdr.Devminor = int64(minor(uint64(s.Rdev)))
|
|
||||||
}
|
|
||||||
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func major(device uint64) uint64 {
|
|
||||||
return (device >> 8) & 0xfff
|
|
||||||
}
|
|
||||||
|
|
||||||
func minor(device uint64) uint64 {
|
|
||||||
return (device & 0xff) | ((device >> 12) & 0xfff00)
|
|
||||||
}
|
|
||||||
|
|
@ -1,12 +0,0 @@
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
)
|
|
||||||
|
|
||||||
func setHeaderForSpecialDevice(hdr *tar.Header, ta *tarAppender, name string, stat interface{}) (nlink uint32, inode uint64, err error) {
|
|
||||||
// do nothing. no notion of Rdev, Inode, Nlink in stat on Windows
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
@ -1,413 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"strings"
|
|
||||||
"syscall"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
|
|
||||||
log "github.com/Sirupsen/logrus"
|
|
||||||
"github.com/docker/docker/pkg/pools"
|
|
||||||
"github.com/docker/docker/pkg/system"
|
|
||||||
)
|
|
||||||
|
|
||||||
type ChangeType int
|
|
||||||
|
|
||||||
const (
|
|
||||||
ChangeModify = iota
|
|
||||||
ChangeAdd
|
|
||||||
ChangeDelete
|
|
||||||
)
|
|
||||||
|
|
||||||
type Change struct {
|
|
||||||
Path string
|
|
||||||
Kind ChangeType
|
|
||||||
}
|
|
||||||
|
|
||||||
func (change *Change) String() string {
|
|
||||||
var kind string
|
|
||||||
switch change.Kind {
|
|
||||||
case ChangeModify:
|
|
||||||
kind = "C"
|
|
||||||
case ChangeAdd:
|
|
||||||
kind = "A"
|
|
||||||
case ChangeDelete:
|
|
||||||
kind = "D"
|
|
||||||
}
|
|
||||||
return fmt.Sprintf("%s %s", kind, change.Path)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Gnu tar and the go tar writer don't have sub-second mtime
|
|
||||||
// precision, which is problematic when we apply changes via tar
|
|
||||||
// files, we handle this by comparing for exact times, *or* same
|
|
||||||
// second count and either a or b having exactly 0 nanoseconds
|
|
||||||
func sameFsTime(a, b time.Time) bool {
|
|
||||||
return a == b ||
|
|
||||||
(a.Unix() == b.Unix() &&
|
|
||||||
(a.Nanosecond() == 0 || b.Nanosecond() == 0))
|
|
||||||
}
|
|
||||||
|
|
||||||
func sameFsTimeSpec(a, b syscall.Timespec) bool {
|
|
||||||
return a.Sec == b.Sec &&
|
|
||||||
(a.Nsec == b.Nsec || a.Nsec == 0 || b.Nsec == 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Changes walks the path rw and determines changes for the files in the path,
|
|
||||||
// with respect to the parent layers
|
|
||||||
func Changes(layers []string, rw string) ([]Change, error) {
|
|
||||||
var changes []Change
|
|
||||||
err := filepath.Walk(rw, func(path string, f os.FileInfo, err error) error {
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Rebase path
|
|
||||||
path, err = filepath.Rel(rw, path)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
path = filepath.Join("/", path)
|
|
||||||
|
|
||||||
// Skip root
|
|
||||||
if path == "/" {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Skip AUFS metadata
|
|
||||||
if matched, err := filepath.Match("/.wh..wh.*", path); err != nil || matched {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
change := Change{
|
|
||||||
Path: path,
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find out what kind of modification happened
|
|
||||||
file := filepath.Base(path)
|
|
||||||
// If there is a whiteout, then the file was removed
|
|
||||||
if strings.HasPrefix(file, ".wh.") {
|
|
||||||
originalFile := file[len(".wh."):]
|
|
||||||
change.Path = filepath.Join(filepath.Dir(path), originalFile)
|
|
||||||
change.Kind = ChangeDelete
|
|
||||||
} else {
|
|
||||||
// Otherwise, the file was added
|
|
||||||
change.Kind = ChangeAdd
|
|
||||||
|
|
||||||
// ...Unless it already existed in a top layer, in which case, it's a modification
|
|
||||||
for _, layer := range layers {
|
|
||||||
stat, err := os.Stat(filepath.Join(layer, path))
|
|
||||||
if err != nil && !os.IsNotExist(err) {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if err == nil {
|
|
||||||
// The file existed in the top layer, so that's a modification
|
|
||||||
|
|
||||||
// However, if it's a directory, maybe it wasn't actually modified.
|
|
||||||
// If you modify /foo/bar/baz, then /foo will be part of the changed files only because it's the parent of bar
|
|
||||||
if stat.IsDir() && f.IsDir() {
|
|
||||||
if f.Size() == stat.Size() && f.Mode() == stat.Mode() && sameFsTime(f.ModTime(), stat.ModTime()) {
|
|
||||||
// Both directories are the same, don't record the change
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
change.Kind = ChangeModify
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Record change
|
|
||||||
changes = append(changes, change)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if err != nil && !os.IsNotExist(err) {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return changes, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
type FileInfo struct {
|
|
||||||
parent *FileInfo
|
|
||||||
name string
|
|
||||||
stat *system.Stat
|
|
||||||
children map[string]*FileInfo
|
|
||||||
capability []byte
|
|
||||||
added bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (root *FileInfo) LookUp(path string) *FileInfo {
|
|
||||||
parent := root
|
|
||||||
if path == "/" {
|
|
||||||
return root
|
|
||||||
}
|
|
||||||
|
|
||||||
pathElements := strings.Split(path, "/")
|
|
||||||
for _, elem := range pathElements {
|
|
||||||
if elem != "" {
|
|
||||||
child := parent.children[elem]
|
|
||||||
if child == nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
parent = child
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return parent
|
|
||||||
}
|
|
||||||
|
|
||||||
func (info *FileInfo) path() string {
|
|
||||||
if info.parent == nil {
|
|
||||||
return "/"
|
|
||||||
}
|
|
||||||
return filepath.Join(info.parent.path(), info.name)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (info *FileInfo) isDir() bool {
|
|
||||||
return info.parent == nil || info.stat.Mode()&syscall.S_IFDIR == syscall.S_IFDIR
|
|
||||||
}
|
|
||||||
|
|
||||||
func (info *FileInfo) addChanges(oldInfo *FileInfo, changes *[]Change) {
|
|
||||||
|
|
||||||
sizeAtEntry := len(*changes)
|
|
||||||
|
|
||||||
if oldInfo == nil {
|
|
||||||
// add
|
|
||||||
change := Change{
|
|
||||||
Path: info.path(),
|
|
||||||
Kind: ChangeAdd,
|
|
||||||
}
|
|
||||||
*changes = append(*changes, change)
|
|
||||||
info.added = true
|
|
||||||
}
|
|
||||||
|
|
||||||
// We make a copy so we can modify it to detect additions
|
|
||||||
// also, we only recurse on the old dir if the new info is a directory
|
|
||||||
// otherwise any previous delete/change is considered recursive
|
|
||||||
oldChildren := make(map[string]*FileInfo)
|
|
||||||
if oldInfo != nil && info.isDir() {
|
|
||||||
for k, v := range oldInfo.children {
|
|
||||||
oldChildren[k] = v
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for name, newChild := range info.children {
|
|
||||||
oldChild, _ := oldChildren[name]
|
|
||||||
if oldChild != nil {
|
|
||||||
// change?
|
|
||||||
oldStat := oldChild.stat
|
|
||||||
newStat := newChild.stat
|
|
||||||
// Note: We can't compare inode or ctime or blocksize here, because these change
|
|
||||||
// when copying a file into a container. However, that is not generally a problem
|
|
||||||
// because any content change will change mtime, and any status change should
|
|
||||||
// be visible when actually comparing the stat fields. The only time this
|
|
||||||
// breaks down is if some code intentionally hides a change by setting
|
|
||||||
// back mtime
|
|
||||||
if oldStat.Mode() != newStat.Mode() ||
|
|
||||||
oldStat.Uid() != newStat.Uid() ||
|
|
||||||
oldStat.Gid() != newStat.Gid() ||
|
|
||||||
oldStat.Rdev() != newStat.Rdev() ||
|
|
||||||
// Don't look at size for dirs, its not a good measure of change
|
|
||||||
(oldStat.Size() != newStat.Size() && oldStat.Mode()&syscall.S_IFDIR != syscall.S_IFDIR) ||
|
|
||||||
!sameFsTimeSpec(oldStat.Mtim(), newStat.Mtim()) ||
|
|
||||||
bytes.Compare(oldChild.capability, newChild.capability) != 0 {
|
|
||||||
change := Change{
|
|
||||||
Path: newChild.path(),
|
|
||||||
Kind: ChangeModify,
|
|
||||||
}
|
|
||||||
*changes = append(*changes, change)
|
|
||||||
newChild.added = true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Remove from copy so we can detect deletions
|
|
||||||
delete(oldChildren, name)
|
|
||||||
}
|
|
||||||
|
|
||||||
newChild.addChanges(oldChild, changes)
|
|
||||||
}
|
|
||||||
for _, oldChild := range oldChildren {
|
|
||||||
// delete
|
|
||||||
change := Change{
|
|
||||||
Path: oldChild.path(),
|
|
||||||
Kind: ChangeDelete,
|
|
||||||
}
|
|
||||||
*changes = append(*changes, change)
|
|
||||||
}
|
|
||||||
|
|
||||||
// If there were changes inside this directory, we need to add it, even if the directory
|
|
||||||
// itself wasn't changed. This is needed to properly save and restore filesystem permissions.
|
|
||||||
if len(*changes) > sizeAtEntry && info.isDir() && !info.added && info.path() != "/" {
|
|
||||||
change := Change{
|
|
||||||
Path: info.path(),
|
|
||||||
Kind: ChangeModify,
|
|
||||||
}
|
|
||||||
// Let's insert the directory entry before the recently added entries located inside this dir
|
|
||||||
*changes = append(*changes, change) // just to resize the slice, will be overwritten
|
|
||||||
copy((*changes)[sizeAtEntry+1:], (*changes)[sizeAtEntry:])
|
|
||||||
(*changes)[sizeAtEntry] = change
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
func (info *FileInfo) Changes(oldInfo *FileInfo) []Change {
|
|
||||||
var changes []Change
|
|
||||||
|
|
||||||
info.addChanges(oldInfo, &changes)
|
|
||||||
|
|
||||||
return changes
|
|
||||||
}
|
|
||||||
|
|
||||||
func newRootFileInfo() *FileInfo {
|
|
||||||
root := &FileInfo{
|
|
||||||
name: "/",
|
|
||||||
children: make(map[string]*FileInfo),
|
|
||||||
}
|
|
||||||
return root
|
|
||||||
}
|
|
||||||
|
|
||||||
func collectFileInfo(sourceDir string) (*FileInfo, error) {
|
|
||||||
root := newRootFileInfo()
|
|
||||||
|
|
||||||
err := filepath.Walk(sourceDir, func(path string, f os.FileInfo, err error) error {
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Rebase path
|
|
||||||
relPath, err := filepath.Rel(sourceDir, path)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
relPath = filepath.Join("/", relPath)
|
|
||||||
|
|
||||||
if relPath == "/" {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
parent := root.LookUp(filepath.Dir(relPath))
|
|
||||||
if parent == nil {
|
|
||||||
return fmt.Errorf("collectFileInfo: Unexpectedly no parent for %s", relPath)
|
|
||||||
}
|
|
||||||
|
|
||||||
info := &FileInfo{
|
|
||||||
name: filepath.Base(relPath),
|
|
||||||
children: make(map[string]*FileInfo),
|
|
||||||
parent: parent,
|
|
||||||
}
|
|
||||||
|
|
||||||
s, err := system.Lstat(path)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
info.stat = s
|
|
||||||
|
|
||||||
info.capability, _ = system.Lgetxattr(path, "security.capability")
|
|
||||||
|
|
||||||
parent.children[info.name] = info
|
|
||||||
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return root, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ChangesDirs compares two directories and generates an array of Change objects describing the changes.
|
|
||||||
// If oldDir is "", then all files in newDir will be Add-Changes.
|
|
||||||
func ChangesDirs(newDir, oldDir string) ([]Change, error) {
|
|
||||||
var (
|
|
||||||
oldRoot, newRoot *FileInfo
|
|
||||||
err1, err2 error
|
|
||||||
errs = make(chan error, 2)
|
|
||||||
)
|
|
||||||
go func() {
|
|
||||||
if oldDir != "" {
|
|
||||||
oldRoot, err1 = collectFileInfo(oldDir)
|
|
||||||
}
|
|
||||||
errs <- err1
|
|
||||||
}()
|
|
||||||
go func() {
|
|
||||||
newRoot, err2 = collectFileInfo(newDir)
|
|
||||||
errs <- err2
|
|
||||||
}()
|
|
||||||
|
|
||||||
// block until both routines have returned
|
|
||||||
for i := 0; i < 2; i++ {
|
|
||||||
if err := <-errs; err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return newRoot.Changes(oldRoot), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ChangesSize calculates the size in bytes of the provided changes, based on newDir.
|
|
||||||
func ChangesSize(newDir string, changes []Change) int64 {
|
|
||||||
var size int64
|
|
||||||
for _, change := range changes {
|
|
||||||
if change.Kind == ChangeModify || change.Kind == ChangeAdd {
|
|
||||||
file := filepath.Join(newDir, change.Path)
|
|
||||||
fileInfo, _ := os.Lstat(file)
|
|
||||||
if fileInfo != nil && !fileInfo.IsDir() {
|
|
||||||
size += fileInfo.Size()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return size
|
|
||||||
}
|
|
||||||
|
|
||||||
// ExportChanges produces an Archive from the provided changes, relative to dir.
|
|
||||||
func ExportChanges(dir string, changes []Change) (Archive, error) {
|
|
||||||
reader, writer := io.Pipe()
|
|
||||||
go func() {
|
|
||||||
ta := &tarAppender{
|
|
||||||
TarWriter: tar.NewWriter(writer),
|
|
||||||
Buffer: pools.BufioWriter32KPool.Get(nil),
|
|
||||||
SeenFiles: make(map[uint64]string),
|
|
||||||
}
|
|
||||||
// this buffer is needed for the duration of this piped stream
|
|
||||||
defer pools.BufioWriter32KPool.Put(ta.Buffer)
|
|
||||||
|
|
||||||
// In general we log errors here but ignore them because
|
|
||||||
// during e.g. a diff operation the container can continue
|
|
||||||
// mutating the filesystem and we can see transient errors
|
|
||||||
// from this
|
|
||||||
for _, change := range changes {
|
|
||||||
if change.Kind == ChangeDelete {
|
|
||||||
whiteOutDir := filepath.Dir(change.Path)
|
|
||||||
whiteOutBase := filepath.Base(change.Path)
|
|
||||||
whiteOut := filepath.Join(whiteOutDir, ".wh."+whiteOutBase)
|
|
||||||
timestamp := time.Now()
|
|
||||||
hdr := &tar.Header{
|
|
||||||
Name: whiteOut[1:],
|
|
||||||
Size: 0,
|
|
||||||
ModTime: timestamp,
|
|
||||||
AccessTime: timestamp,
|
|
||||||
ChangeTime: timestamp,
|
|
||||||
}
|
|
||||||
if err := ta.TarWriter.WriteHeader(hdr); err != nil {
|
|
||||||
log.Debugf("Can't write whiteout header: %s", err)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
path := filepath.Join(dir, change.Path)
|
|
||||||
if err := ta.addTarFile(path, change.Path[1:]); err != nil {
|
|
||||||
log.Debugf("Can't add file %s to tar: %s", path, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Make sure to check the error on Close.
|
|
||||||
if err := ta.TarWriter.Close(); err != nil {
|
|
||||||
log.Debugf("Can't close layer: %s", err)
|
|
||||||
}
|
|
||||||
if err := writer.Close(); err != nil {
|
|
||||||
log.Debugf("failed close Changes writer: %s", err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
return reader, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,301 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"os/exec"
|
|
||||||
"path"
|
|
||||||
"sort"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
func max(x, y int) int {
|
|
||||||
if x >= y {
|
|
||||||
return x
|
|
||||||
}
|
|
||||||
return y
|
|
||||||
}
|
|
||||||
|
|
||||||
func copyDir(src, dst string) error {
|
|
||||||
cmd := exec.Command("cp", "-a", src, dst)
|
|
||||||
if err := cmd.Run(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Helper to sort []Change by path
|
|
||||||
type byPath struct{ changes []Change }
|
|
||||||
|
|
||||||
func (b byPath) Less(i, j int) bool { return b.changes[i].Path < b.changes[j].Path }
|
|
||||||
func (b byPath) Len() int { return len(b.changes) }
|
|
||||||
func (b byPath) Swap(i, j int) { b.changes[i], b.changes[j] = b.changes[j], b.changes[i] }
|
|
||||||
|
|
||||||
type FileType uint32
|
|
||||||
|
|
||||||
const (
|
|
||||||
Regular FileType = iota
|
|
||||||
Dir
|
|
||||||
Symlink
|
|
||||||
)
|
|
||||||
|
|
||||||
type FileData struct {
|
|
||||||
filetype FileType
|
|
||||||
path string
|
|
||||||
contents string
|
|
||||||
permissions os.FileMode
|
|
||||||
}
|
|
||||||
|
|
||||||
func createSampleDir(t *testing.T, root string) {
|
|
||||||
files := []FileData{
|
|
||||||
{Regular, "file1", "file1\n", 0600},
|
|
||||||
{Regular, "file2", "file2\n", 0666},
|
|
||||||
{Regular, "file3", "file3\n", 0404},
|
|
||||||
{Regular, "file4", "file4\n", 0600},
|
|
||||||
{Regular, "file5", "file5\n", 0600},
|
|
||||||
{Regular, "file6", "file6\n", 0600},
|
|
||||||
{Regular, "file7", "file7\n", 0600},
|
|
||||||
{Dir, "dir1", "", 0740},
|
|
||||||
{Regular, "dir1/file1-1", "file1-1\n", 01444},
|
|
||||||
{Regular, "dir1/file1-2", "file1-2\n", 0666},
|
|
||||||
{Dir, "dir2", "", 0700},
|
|
||||||
{Regular, "dir2/file2-1", "file2-1\n", 0666},
|
|
||||||
{Regular, "dir2/file2-2", "file2-2\n", 0666},
|
|
||||||
{Dir, "dir3", "", 0700},
|
|
||||||
{Regular, "dir3/file3-1", "file3-1\n", 0666},
|
|
||||||
{Regular, "dir3/file3-2", "file3-2\n", 0666},
|
|
||||||
{Dir, "dir4", "", 0700},
|
|
||||||
{Regular, "dir4/file3-1", "file4-1\n", 0666},
|
|
||||||
{Regular, "dir4/file3-2", "file4-2\n", 0666},
|
|
||||||
{Symlink, "symlink1", "target1", 0666},
|
|
||||||
{Symlink, "symlink2", "target2", 0666},
|
|
||||||
}
|
|
||||||
|
|
||||||
now := time.Now()
|
|
||||||
for _, info := range files {
|
|
||||||
p := path.Join(root, info.path)
|
|
||||||
if info.filetype == Dir {
|
|
||||||
if err := os.MkdirAll(p, info.permissions); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
} else if info.filetype == Regular {
|
|
||||||
if err := ioutil.WriteFile(p, []byte(info.contents), info.permissions); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
} else if info.filetype == Symlink {
|
|
||||||
if err := os.Symlink(info.contents, p); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if info.filetype != Symlink {
|
|
||||||
// Set a consistent ctime, atime for all files and dirs
|
|
||||||
if err := os.Chtimes(p, now, now); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create an directory, copy it, make sure we report no changes between the two
|
|
||||||
func TestChangesDirsEmpty(t *testing.T) {
|
|
||||||
src, err := ioutil.TempDir("", "docker-changes-test")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
createSampleDir(t, src)
|
|
||||||
dst := src + "-copy"
|
|
||||||
if err := copyDir(src, dst); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
changes, err := ChangesDirs(dst, src)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(changes) != 0 {
|
|
||||||
t.Fatalf("Reported changes for identical dirs: %v", changes)
|
|
||||||
}
|
|
||||||
os.RemoveAll(src)
|
|
||||||
os.RemoveAll(dst)
|
|
||||||
}
|
|
||||||
|
|
||||||
func mutateSampleDir(t *testing.T, root string) {
|
|
||||||
// Remove a regular file
|
|
||||||
if err := os.RemoveAll(path.Join(root, "file1")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Remove a directory
|
|
||||||
if err := os.RemoveAll(path.Join(root, "dir1")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Remove a symlink
|
|
||||||
if err := os.RemoveAll(path.Join(root, "symlink1")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Rewrite a file
|
|
||||||
if err := ioutil.WriteFile(path.Join(root, "file2"), []byte("fileNN\n"), 0777); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Replace a file
|
|
||||||
if err := os.RemoveAll(path.Join(root, "file3")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := ioutil.WriteFile(path.Join(root, "file3"), []byte("fileMM\n"), 0404); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Touch file
|
|
||||||
if err := os.Chtimes(path.Join(root, "file4"), time.Now().Add(time.Second), time.Now().Add(time.Second)); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Replace file with dir
|
|
||||||
if err := os.RemoveAll(path.Join(root, "file5")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := os.MkdirAll(path.Join(root, "file5"), 0666); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create new file
|
|
||||||
if err := ioutil.WriteFile(path.Join(root, "filenew"), []byte("filenew\n"), 0777); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create new dir
|
|
||||||
if err := os.MkdirAll(path.Join(root, "dirnew"), 0766); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a new symlink
|
|
||||||
if err := os.Symlink("targetnew", path.Join(root, "symlinknew")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Change a symlink
|
|
||||||
if err := os.RemoveAll(path.Join(root, "symlink2")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := os.Symlink("target2change", path.Join(root, "symlink2")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Replace dir with file
|
|
||||||
if err := os.RemoveAll(path.Join(root, "dir2")); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := ioutil.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0777); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Touch dir
|
|
||||||
if err := os.Chtimes(path.Join(root, "dir3"), time.Now().Add(time.Second), time.Now().Add(time.Second)); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestChangesDirsMutated(t *testing.T) {
|
|
||||||
src, err := ioutil.TempDir("", "docker-changes-test")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
createSampleDir(t, src)
|
|
||||||
dst := src + "-copy"
|
|
||||||
if err := copyDir(src, dst); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(src)
|
|
||||||
defer os.RemoveAll(dst)
|
|
||||||
|
|
||||||
mutateSampleDir(t, dst)
|
|
||||||
|
|
||||||
changes, err := ChangesDirs(dst, src)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
sort.Sort(byPath{changes})
|
|
||||||
|
|
||||||
expectedChanges := []Change{
|
|
||||||
{"/dir1", ChangeDelete},
|
|
||||||
{"/dir2", ChangeModify},
|
|
||||||
{"/dir3", ChangeModify},
|
|
||||||
{"/dirnew", ChangeAdd},
|
|
||||||
{"/file1", ChangeDelete},
|
|
||||||
{"/file2", ChangeModify},
|
|
||||||
{"/file3", ChangeModify},
|
|
||||||
{"/file4", ChangeModify},
|
|
||||||
{"/file5", ChangeModify},
|
|
||||||
{"/filenew", ChangeAdd},
|
|
||||||
{"/symlink1", ChangeDelete},
|
|
||||||
{"/symlink2", ChangeModify},
|
|
||||||
{"/symlinknew", ChangeAdd},
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i < max(len(changes), len(expectedChanges)); i++ {
|
|
||||||
if i >= len(expectedChanges) {
|
|
||||||
t.Fatalf("unexpected change %s\n", changes[i].String())
|
|
||||||
}
|
|
||||||
if i >= len(changes) {
|
|
||||||
t.Fatalf("no change for expected change %s\n", expectedChanges[i].String())
|
|
||||||
}
|
|
||||||
if changes[i].Path == expectedChanges[i].Path {
|
|
||||||
if changes[i] != expectedChanges[i] {
|
|
||||||
t.Fatalf("Wrong change for %s, expected %s, got %s\n", changes[i].Path, changes[i].String(), expectedChanges[i].String())
|
|
||||||
}
|
|
||||||
} else if changes[i].Path < expectedChanges[i].Path {
|
|
||||||
t.Fatalf("unexpected change %s\n", changes[i].String())
|
|
||||||
} else {
|
|
||||||
t.Fatalf("no change for expected change %s != %s\n", expectedChanges[i].String(), changes[i].String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyLayer(t *testing.T) {
|
|
||||||
src, err := ioutil.TempDir("", "docker-changes-test")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
createSampleDir(t, src)
|
|
||||||
defer os.RemoveAll(src)
|
|
||||||
dst := src + "-copy"
|
|
||||||
if err := copyDir(src, dst); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
mutateSampleDir(t, dst)
|
|
||||||
defer os.RemoveAll(dst)
|
|
||||||
|
|
||||||
changes, err := ChangesDirs(dst, src)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
layer, err := ExportChanges(dst, changes)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
layerCopy, err := NewTempArchive(layer, "")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if _, err := ApplyLayer(src, layerCopy); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
changes2, err := ChangesDirs(src, dst)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(changes2) != 0 {
|
|
||||||
t.Fatalf("Unexpected differences after reapplying mutation: %v", changes2)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,169 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"strings"
|
|
||||||
"syscall"
|
|
||||||
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/pools"
|
|
||||||
"github.com/docker/docker/pkg/system"
|
|
||||||
)
|
|
||||||
|
|
||||||
func UnpackLayer(dest string, layer ArchiveReader) (size int64, err error) {
|
|
||||||
tr := tar.NewReader(layer)
|
|
||||||
trBuf := pools.BufioReader32KPool.Get(tr)
|
|
||||||
defer pools.BufioReader32KPool.Put(trBuf)
|
|
||||||
|
|
||||||
var dirs []*tar.Header
|
|
||||||
|
|
||||||
aufsTempdir := ""
|
|
||||||
aufsHardlinks := make(map[string]*tar.Header)
|
|
||||||
|
|
||||||
// Iterate through the files in the archive.
|
|
||||||
for {
|
|
||||||
hdr, err := tr.Next()
|
|
||||||
if err == io.EOF {
|
|
||||||
// end of tar archive
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
|
|
||||||
size += hdr.Size
|
|
||||||
|
|
||||||
// Normalize name, for safety and for a simple is-root check
|
|
||||||
hdr.Name = filepath.Clean(hdr.Name)
|
|
||||||
|
|
||||||
if !strings.HasSuffix(hdr.Name, "/") {
|
|
||||||
// Not the root directory, ensure that the parent directory exists.
|
|
||||||
// This happened in some tests where an image had a tarfile without any
|
|
||||||
// parent directories.
|
|
||||||
parent := filepath.Dir(hdr.Name)
|
|
||||||
parentPath := filepath.Join(dest, parent)
|
|
||||||
if _, err := os.Lstat(parentPath); err != nil && os.IsNotExist(err) {
|
|
||||||
err = os.MkdirAll(parentPath, 0600)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Skip AUFS metadata dirs
|
|
||||||
if strings.HasPrefix(hdr.Name, ".wh..wh.") {
|
|
||||||
// Regular files inside /.wh..wh.plnk can be used as hardlink targets
|
|
||||||
// We don't want this directory, but we need the files in them so that
|
|
||||||
// such hardlinks can be resolved.
|
|
||||||
if strings.HasPrefix(hdr.Name, ".wh..wh.plnk") && hdr.Typeflag == tar.TypeReg {
|
|
||||||
basename := filepath.Base(hdr.Name)
|
|
||||||
aufsHardlinks[basename] = hdr
|
|
||||||
if aufsTempdir == "" {
|
|
||||||
if aufsTempdir, err = ioutil.TempDir("", "dockerplnk"); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(aufsTempdir)
|
|
||||||
}
|
|
||||||
if err := createTarFile(filepath.Join(aufsTempdir, basename), dest, hdr, tr, true); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
path := filepath.Join(dest, hdr.Name)
|
|
||||||
rel, err := filepath.Rel(dest, path)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
if strings.HasPrefix(rel, "..") {
|
|
||||||
return 0, breakoutError(fmt.Errorf("%q is outside of %q", hdr.Name, dest))
|
|
||||||
}
|
|
||||||
base := filepath.Base(path)
|
|
||||||
|
|
||||||
if strings.HasPrefix(base, ".wh.") {
|
|
||||||
originalBase := base[len(".wh."):]
|
|
||||||
originalPath := filepath.Join(filepath.Dir(path), originalBase)
|
|
||||||
if err := os.RemoveAll(originalPath); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// If path exits we almost always just want to remove and replace it.
|
|
||||||
// The only exception is when it is a directory *and* the file from
|
|
||||||
// the layer is also a directory. Then we want to merge them (i.e.
|
|
||||||
// just apply the metadata from the layer).
|
|
||||||
if fi, err := os.Lstat(path); err == nil {
|
|
||||||
if !(fi.IsDir() && hdr.Typeflag == tar.TypeDir) {
|
|
||||||
if err := os.RemoveAll(path); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
trBuf.Reset(tr)
|
|
||||||
srcData := io.Reader(trBuf)
|
|
||||||
srcHdr := hdr
|
|
||||||
|
|
||||||
// Hard links into /.wh..wh.plnk don't work, as we don't extract that directory, so
|
|
||||||
// we manually retarget these into the temporary files we extracted them into
|
|
||||||
if hdr.Typeflag == tar.TypeLink && strings.HasPrefix(filepath.Clean(hdr.Linkname), ".wh..wh.plnk") {
|
|
||||||
linkBasename := filepath.Base(hdr.Linkname)
|
|
||||||
srcHdr = aufsHardlinks[linkBasename]
|
|
||||||
if srcHdr == nil {
|
|
||||||
return 0, fmt.Errorf("Invalid aufs hardlink")
|
|
||||||
}
|
|
||||||
tmpFile, err := os.Open(filepath.Join(aufsTempdir, linkBasename))
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
defer tmpFile.Close()
|
|
||||||
srcData = tmpFile
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := createTarFile(path, dest, srcHdr, srcData, true); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Directory mtimes must be handled at the end to avoid further
|
|
||||||
// file creation in them to modify the directory mtime
|
|
||||||
if hdr.Typeflag == tar.TypeDir {
|
|
||||||
dirs = append(dirs, hdr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, hdr := range dirs {
|
|
||||||
path := filepath.Join(dest, hdr.Name)
|
|
||||||
ts := []syscall.Timespec{timeToTimespec(hdr.AccessTime), timeToTimespec(hdr.ModTime)}
|
|
||||||
if err := syscall.UtimesNano(path, ts); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return size, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ApplyLayer parses a diff in the standard layer format from `layer`, and
|
|
||||||
// applies it to the directory `dest`. Returns the size in bytes of the
|
|
||||||
// contents of the layer.
|
|
||||||
func ApplyLayer(dest string, layer ArchiveReader) (int64, error) {
|
|
||||||
dest = filepath.Clean(dest)
|
|
||||||
|
|
||||||
// We need to be able to set any perms
|
|
||||||
oldmask, err := system.Umask(0)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
defer system.Umask(oldmask) // ignore err, ErrNotSupportedPlatform
|
|
||||||
|
|
||||||
layer, err = DecompressStream(layer)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
return UnpackLayer(dest, layer)
|
|
||||||
}
|
|
||||||
|
|
@ -1,191 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestApplyLayerInvalidFilenames(t *testing.T) {
|
|
||||||
for i, headers := range [][]*tar.Header{
|
|
||||||
{
|
|
||||||
{
|
|
||||||
Name: "../victim/dotdot",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{
|
|
||||||
{
|
|
||||||
// Note the leading slash
|
|
||||||
Name: "/../victim/slash-dotdot",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
} {
|
|
||||||
if err := testBreakout("applylayer", "docker-TestApplyLayerInvalidFilenames", headers); err != nil {
|
|
||||||
t.Fatalf("i=%d. %v", i, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyLayerInvalidHardlink(t *testing.T) {
|
|
||||||
for i, headers := range [][]*tar.Header{
|
|
||||||
{ // try reading victim/hello (../)
|
|
||||||
{
|
|
||||||
Name: "dotdot",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (/../)
|
|
||||||
{
|
|
||||||
Name: "slash-dotdot",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
// Note the leading slash
|
|
||||||
Linkname: "/../victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try writing victim/file
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "loophole-victim/file",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (hardlink, symlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "symlink",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "loophole-victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // Try reading victim/hello (hardlink, hardlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "hardlink",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "loophole-victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // Try removing victim directory (hardlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
} {
|
|
||||||
if err := testBreakout("applylayer", "docker-TestApplyLayerInvalidHardlink", headers); err != nil {
|
|
||||||
t.Fatalf("i=%d. %v", i, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyLayerInvalidSymlink(t *testing.T) {
|
|
||||||
for i, headers := range [][]*tar.Header{
|
|
||||||
{ // try reading victim/hello (../)
|
|
||||||
{
|
|
||||||
Name: "dotdot",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (/../)
|
|
||||||
{
|
|
||||||
Name: "slash-dotdot",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
// Note the leading slash
|
|
||||||
Linkname: "/../victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try writing victim/file
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "loophole-victim/file",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (symlink, symlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "symlink",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "loophole-victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try reading victim/hello (symlink, hardlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "hardlink",
|
|
||||||
Typeflag: tar.TypeLink,
|
|
||||||
Linkname: "loophole-victim/hello",
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
{ // try removing victim directory (symlink)
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeSymlink,
|
|
||||||
Linkname: "../victim",
|
|
||||||
Mode: 0755,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
Name: "loophole-victim",
|
|
||||||
Typeflag: tar.TypeReg,
|
|
||||||
Mode: 0644,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
} {
|
|
||||||
if err := testBreakout("applylayer", "docker-TestApplyLayerInvalidSymlink", headers); err != nil {
|
|
||||||
t.Fatalf("i=%d. %v", i, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,97 +0,0 @@
|
||||||
// +build ignore
|
|
||||||
|
|
||||||
// Simple tool to create an archive stream from an old and new directory
|
|
||||||
//
|
|
||||||
// By default it will stream the comparison of two temporary directories with junk files
|
|
||||||
package main
|
|
||||||
|
|
||||||
import (
|
|
||||||
"flag"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"path"
|
|
||||||
|
|
||||||
"github.com/Sirupsen/logrus"
|
|
||||||
"github.com/docker/docker/pkg/archive"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
flDebug = flag.Bool("D", false, "debugging output")
|
|
||||||
flNewDir = flag.String("newdir", "", "")
|
|
||||||
flOldDir = flag.String("olddir", "", "")
|
|
||||||
log = logrus.New()
|
|
||||||
)
|
|
||||||
|
|
||||||
func main() {
|
|
||||||
flag.Usage = func() {
|
|
||||||
fmt.Println("Produce a tar from comparing two directory paths. By default a demo tar is created of around 200 files (including hardlinks)")
|
|
||||||
fmt.Printf("%s [OPTIONS]\n", os.Args[0])
|
|
||||||
flag.PrintDefaults()
|
|
||||||
}
|
|
||||||
flag.Parse()
|
|
||||||
log.Out = os.Stderr
|
|
||||||
if (len(os.Getenv("DEBUG")) > 0) || *flDebug {
|
|
||||||
logrus.SetLevel(logrus.DebugLevel)
|
|
||||||
}
|
|
||||||
var newDir, oldDir string
|
|
||||||
|
|
||||||
if len(*flNewDir) == 0 {
|
|
||||||
var err error
|
|
||||||
newDir, err = ioutil.TempDir("", "docker-test-newDir")
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(newDir)
|
|
||||||
if _, err := prepareUntarSourceDirectory(100, newDir, true); err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
newDir = *flNewDir
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(*flOldDir) == 0 {
|
|
||||||
oldDir, err := ioutil.TempDir("", "docker-test-oldDir")
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(oldDir)
|
|
||||||
} else {
|
|
||||||
oldDir = *flOldDir
|
|
||||||
}
|
|
||||||
|
|
||||||
changes, err := archive.ChangesDirs(newDir, oldDir)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
a, err := archive.ExportChanges(newDir, changes)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
defer a.Close()
|
|
||||||
|
|
||||||
i, err := io.Copy(os.Stdout, a)
|
|
||||||
if err != nil && err != io.EOF {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
fmt.Fprintf(os.Stderr, "wrote archive of %d bytes", i)
|
|
||||||
}
|
|
||||||
|
|
||||||
func prepareUntarSourceDirectory(numberOfFiles int, targetPath string, makeLinks bool) (int, error) {
|
|
||||||
fileData := []byte("fooo")
|
|
||||||
for n := 0; n < numberOfFiles; n++ {
|
|
||||||
fileName := fmt.Sprintf("file-%d", n)
|
|
||||||
if err := ioutil.WriteFile(path.Join(targetPath, fileName), fileData, 0700); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
if makeLinks {
|
|
||||||
if err := os.Link(path.Join(targetPath, fileName), path.Join(targetPath, fileName+"-link")); err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
totalSize := numberOfFiles * len(fileData)
|
|
||||||
return totalSize, nil
|
|
||||||
}
|
|
||||||
BIN
Godeps/_workspace/src/github.com/docker/docker/pkg/archive/testdata/broken.tar
generated
vendored
BIN
Godeps/_workspace/src/github.com/docker/docker/pkg/archive/testdata/broken.tar
generated
vendored
Binary file not shown.
|
|
@ -1,16 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
func timeToTimespec(time time.Time) (ts syscall.Timespec) {
|
|
||||||
if time.IsZero() {
|
|
||||||
// Return UTIME_OMIT special value
|
|
||||||
ts.Sec = 0
|
|
||||||
ts.Nsec = ((1 << 30) - 2)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
return syscall.NsecToTimespec(time.UnixNano())
|
|
||||||
}
|
|
||||||
16
Godeps/_workspace/src/github.com/docker/docker/pkg/archive/time_unsupported.go
generated
vendored
16
Godeps/_workspace/src/github.com/docker/docker/pkg/archive/time_unsupported.go
generated
vendored
|
|
@ -1,16 +0,0 @@
|
||||||
// +build !linux
|
|
||||||
|
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
func timeToTimespec(time time.Time) (ts syscall.Timespec) {
|
|
||||||
nsec := int64(0)
|
|
||||||
if !time.IsZero() {
|
|
||||||
nsec = time.UnixNano()
|
|
||||||
}
|
|
||||||
return syscall.NsecToTimespec(nsec)
|
|
||||||
}
|
|
||||||
|
|
@ -1,167 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
)
|
|
||||||
|
|
||||||
var testUntarFns = map[string]func(string, io.Reader) error{
|
|
||||||
"untar": func(dest string, r io.Reader) error {
|
|
||||||
return Untar(r, dest, nil)
|
|
||||||
},
|
|
||||||
"applylayer": func(dest string, r io.Reader) error {
|
|
||||||
_, err := ApplyLayer(dest, ArchiveReader(r))
|
|
||||||
return err
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
// testBreakout is a helper function that, within the provided `tmpdir` directory,
|
|
||||||
// creates a `victim` folder with a generated `hello` file in it.
|
|
||||||
// `untar` extracts to a directory named `dest`, the tar file created from `headers`.
|
|
||||||
//
|
|
||||||
// Here are the tested scenarios:
|
|
||||||
// - removed `victim` folder (write)
|
|
||||||
// - removed files from `victim` folder (write)
|
|
||||||
// - new files in `victim` folder (write)
|
|
||||||
// - modified files in `victim` folder (write)
|
|
||||||
// - file in `dest` with same content as `victim/hello` (read)
|
|
||||||
//
|
|
||||||
// When using testBreakout make sure you cover one of the scenarios listed above.
|
|
||||||
func testBreakout(untarFn string, tmpdir string, headers []*tar.Header) error {
|
|
||||||
tmpdir, err := ioutil.TempDir("", tmpdir)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer os.RemoveAll(tmpdir)
|
|
||||||
|
|
||||||
dest := filepath.Join(tmpdir, "dest")
|
|
||||||
if err := os.Mkdir(dest, 0755); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
victim := filepath.Join(tmpdir, "victim")
|
|
||||||
if err := os.Mkdir(victim, 0755); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
hello := filepath.Join(victim, "hello")
|
|
||||||
helloData, err := time.Now().MarshalText()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if err := ioutil.WriteFile(hello, helloData, 0644); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
helloStat, err := os.Stat(hello)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
reader, writer := io.Pipe()
|
|
||||||
go func() {
|
|
||||||
t := tar.NewWriter(writer)
|
|
||||||
for _, hdr := range headers {
|
|
||||||
t.WriteHeader(hdr)
|
|
||||||
}
|
|
||||||
t.Close()
|
|
||||||
}()
|
|
||||||
|
|
||||||
untar := testUntarFns[untarFn]
|
|
||||||
if untar == nil {
|
|
||||||
return fmt.Errorf("could not find untar function %q in testUntarFns", untarFn)
|
|
||||||
}
|
|
||||||
if err := untar(dest, reader); err != nil {
|
|
||||||
if _, ok := err.(breakoutError); !ok {
|
|
||||||
// If untar returns an error unrelated to an archive breakout,
|
|
||||||
// then consider this an unexpected error and abort.
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
// Here, untar detected the breakout.
|
|
||||||
// Let's move on verifying that indeed there was no breakout.
|
|
||||||
fmt.Printf("breakoutError: %v\n", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check victim folder
|
|
||||||
f, err := os.Open(victim)
|
|
||||||
if err != nil {
|
|
||||||
// codepath taken if victim folder was removed
|
|
||||||
return fmt.Errorf("archive breakout: error reading %q: %v", victim, err)
|
|
||||||
}
|
|
||||||
defer f.Close()
|
|
||||||
|
|
||||||
// Check contents of victim folder
|
|
||||||
//
|
|
||||||
// We are only interested in getting 2 files from the victim folder, because if all is well
|
|
||||||
// we expect only one result, the `hello` file. If there is a second result, it cannot
|
|
||||||
// hold the same name `hello` and we assume that a new file got created in the victim folder.
|
|
||||||
// That is enough to detect an archive breakout.
|
|
||||||
names, err := f.Readdirnames(2)
|
|
||||||
if err != nil {
|
|
||||||
// codepath taken if victim is not a folder
|
|
||||||
return fmt.Errorf("archive breakout: error reading directory content of %q: %v", victim, err)
|
|
||||||
}
|
|
||||||
for _, name := range names {
|
|
||||||
if name != "hello" {
|
|
||||||
// codepath taken if new file was created in victim folder
|
|
||||||
return fmt.Errorf("archive breakout: new file %q", name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check victim/hello
|
|
||||||
f, err = os.Open(hello)
|
|
||||||
if err != nil {
|
|
||||||
// codepath taken if read permissions were removed
|
|
||||||
return fmt.Errorf("archive breakout: could not lstat %q: %v", hello, err)
|
|
||||||
}
|
|
||||||
defer f.Close()
|
|
||||||
b, err := ioutil.ReadAll(f)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
fi, err := f.Stat()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if helloStat.IsDir() != fi.IsDir() ||
|
|
||||||
// TODO: cannot check for fi.ModTime() change
|
|
||||||
helloStat.Mode() != fi.Mode() ||
|
|
||||||
helloStat.Size() != fi.Size() ||
|
|
||||||
!bytes.Equal(helloData, b) {
|
|
||||||
// codepath taken if hello has been modified
|
|
||||||
return fmt.Errorf("archive breakout: file %q has been modified. Contents: expected=%q, got=%q. FileInfo: expected=%#v, got=%#v.", hello, helloData, b, helloStat, fi)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check that nothing in dest/ has the same content as victim/hello.
|
|
||||||
// Since victim/hello was generated with time.Now(), it is safe to assume
|
|
||||||
// that any file whose content matches exactly victim/hello, managed somehow
|
|
||||||
// to access victim/hello.
|
|
||||||
return filepath.Walk(dest, func(path string, info os.FileInfo, err error) error {
|
|
||||||
if info.IsDir() {
|
|
||||||
if err != nil {
|
|
||||||
// skip directory if error
|
|
||||||
return filepath.SkipDir
|
|
||||||
}
|
|
||||||
// enter directory
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
// skip file if error
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
b, err := ioutil.ReadFile(path)
|
|
||||||
if err != nil {
|
|
||||||
// Houston, we have a problem. Aborting (space)walk.
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if bytes.Equal(helloData, b) {
|
|
||||||
return fmt.Errorf("archive breakout: file %q has been accessed via %q", hello, path)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
@ -1,59 +0,0 @@
|
||||||
package archive
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
|
|
||||||
"io/ioutil"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Generate generates a new archive from the content provided
|
|
||||||
// as input.
|
|
||||||
//
|
|
||||||
// `files` is a sequence of path/content pairs. A new file is
|
|
||||||
// added to the archive for each pair.
|
|
||||||
// If the last pair is incomplete, the file is created with an
|
|
||||||
// empty content. For example:
|
|
||||||
//
|
|
||||||
// Generate("foo.txt", "hello world", "emptyfile")
|
|
||||||
//
|
|
||||||
// The above call will return an archive with 2 files:
|
|
||||||
// * ./foo.txt with content "hello world"
|
|
||||||
// * ./empty with empty content
|
|
||||||
//
|
|
||||||
// FIXME: stream content instead of buffering
|
|
||||||
// FIXME: specify permissions and other archive metadata
|
|
||||||
func Generate(input ...string) (Archive, error) {
|
|
||||||
files := parseStringPairs(input...)
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
tw := tar.NewWriter(buf)
|
|
||||||
for _, file := range files {
|
|
||||||
name, content := file[0], file[1]
|
|
||||||
hdr := &tar.Header{
|
|
||||||
Name: name,
|
|
||||||
Size: int64(len(content)),
|
|
||||||
}
|
|
||||||
if err := tw.WriteHeader(hdr); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
if _, err := tw.Write([]byte(content)); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if err := tw.Close(); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return ioutil.NopCloser(buf), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func parseStringPairs(input ...string) (output [][2]string) {
|
|
||||||
output = make([][2]string, 0, len(input)/2+1)
|
|
||||||
for i := 0; i < len(input); i += 2 {
|
|
||||||
var pair [2]string
|
|
||||||
pair[0] = input[i]
|
|
||||||
if i+1 < len(input) {
|
|
||||||
pair[1] = input[i+1]
|
|
||||||
}
|
|
||||||
output = append(output, pair)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
@ -1,26 +0,0 @@
|
||||||
package fileutils
|
|
||||||
|
|
||||||
import (
|
|
||||||
log "github.com/Sirupsen/logrus"
|
|
||||||
"path/filepath"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Matches returns true if relFilePath matches any of the patterns
|
|
||||||
func Matches(relFilePath string, patterns []string) (bool, error) {
|
|
||||||
for _, exclude := range patterns {
|
|
||||||
matched, err := filepath.Match(exclude, relFilePath)
|
|
||||||
if err != nil {
|
|
||||||
log.Errorf("Error matching: %s (pattern: %s)", relFilePath, exclude)
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
if matched {
|
|
||||||
if filepath.Clean(relFilePath) == "." {
|
|
||||||
log.Errorf("Can't exclude whole path, excluding pattern: %s", exclude)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
log.Debugf("Skipping excluded path: %s", relFilePath)
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,114 +0,0 @@
|
||||||
package ioutils
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
type readCloserWrapper struct {
|
|
||||||
io.Reader
|
|
||||||
closer func() error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *readCloserWrapper) Close() error {
|
|
||||||
return r.closer()
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewReadCloserWrapper(r io.Reader, closer func() error) io.ReadCloser {
|
|
||||||
return &readCloserWrapper{
|
|
||||||
Reader: r,
|
|
||||||
closer: closer,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type readerErrWrapper struct {
|
|
||||||
reader io.Reader
|
|
||||||
closer func()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *readerErrWrapper) Read(p []byte) (int, error) {
|
|
||||||
n, err := r.reader.Read(p)
|
|
||||||
if err != nil {
|
|
||||||
r.closer()
|
|
||||||
}
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewReaderErrWrapper(r io.Reader, closer func()) io.Reader {
|
|
||||||
return &readerErrWrapper{
|
|
||||||
reader: r,
|
|
||||||
closer: closer,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type bufReader struct {
|
|
||||||
sync.Mutex
|
|
||||||
buf *bytes.Buffer
|
|
||||||
reader io.Reader
|
|
||||||
err error
|
|
||||||
wait sync.Cond
|
|
||||||
drainBuf []byte
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewBufReader(r io.Reader) *bufReader {
|
|
||||||
reader := &bufReader{
|
|
||||||
buf: &bytes.Buffer{},
|
|
||||||
drainBuf: make([]byte, 1024),
|
|
||||||
reader: r,
|
|
||||||
}
|
|
||||||
reader.wait.L = &reader.Mutex
|
|
||||||
go reader.drain()
|
|
||||||
return reader
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewBufReaderWithDrainbufAndBuffer(r io.Reader, drainBuffer []byte, buffer *bytes.Buffer) *bufReader {
|
|
||||||
reader := &bufReader{
|
|
||||||
buf: buffer,
|
|
||||||
drainBuf: drainBuffer,
|
|
||||||
reader: r,
|
|
||||||
}
|
|
||||||
reader.wait.L = &reader.Mutex
|
|
||||||
go reader.drain()
|
|
||||||
return reader
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *bufReader) drain() {
|
|
||||||
for {
|
|
||||||
n, err := r.reader.Read(r.drainBuf)
|
|
||||||
r.Lock()
|
|
||||||
if err != nil {
|
|
||||||
r.err = err
|
|
||||||
} else {
|
|
||||||
r.buf.Write(r.drainBuf[0:n])
|
|
||||||
}
|
|
||||||
r.wait.Signal()
|
|
||||||
r.Unlock()
|
|
||||||
if err != nil {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *bufReader) Read(p []byte) (n int, err error) {
|
|
||||||
r.Lock()
|
|
||||||
defer r.Unlock()
|
|
||||||
for {
|
|
||||||
n, err = r.buf.Read(p)
|
|
||||||
if n > 0 {
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
if r.err != nil {
|
|
||||||
return 0, r.err
|
|
||||||
}
|
|
||||||
r.wait.Wait()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *bufReader) Close() error {
|
|
||||||
closer, ok := r.reader.(io.ReadCloser)
|
|
||||||
if !ok {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return closer.Close()
|
|
||||||
}
|
|
||||||
|
|
@ -1,34 +0,0 @@
|
||||||
package ioutils
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestBufReader(t *testing.T) {
|
|
||||||
reader, writer := io.Pipe()
|
|
||||||
bufreader := NewBufReader(reader)
|
|
||||||
|
|
||||||
// Write everything down to a Pipe
|
|
||||||
// Usually, a pipe should block but because of the buffered reader,
|
|
||||||
// the writes will go through
|
|
||||||
done := make(chan bool)
|
|
||||||
go func() {
|
|
||||||
writer.Write([]byte("hello world"))
|
|
||||||
writer.Close()
|
|
||||||
done <- true
|
|
||||||
}()
|
|
||||||
|
|
||||||
// Drain the reader *after* everything has been written, just to verify
|
|
||||||
// it is indeed buffering
|
|
||||||
<-done
|
|
||||||
output, err := ioutil.ReadAll(bufreader)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if !bytes.Equal(output, []byte("hello world")) {
|
|
||||||
t.Error(string(output))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,39 +0,0 @@
|
||||||
package ioutils
|
|
||||||
|
|
||||||
import "io"
|
|
||||||
|
|
||||||
type NopWriter struct{}
|
|
||||||
|
|
||||||
func (*NopWriter) Write(buf []byte) (int, error) {
|
|
||||||
return len(buf), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
type nopWriteCloser struct {
|
|
||||||
io.Writer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *nopWriteCloser) Close() error { return nil }
|
|
||||||
|
|
||||||
func NopWriteCloser(w io.Writer) io.WriteCloser {
|
|
||||||
return &nopWriteCloser{w}
|
|
||||||
}
|
|
||||||
|
|
||||||
type NopFlusher struct{}
|
|
||||||
|
|
||||||
func (f *NopFlusher) Flush() {}
|
|
||||||
|
|
||||||
type writeCloserWrapper struct {
|
|
||||||
io.Writer
|
|
||||||
closer func() error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *writeCloserWrapper) Close() error {
|
|
||||||
return r.closer()
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewWriteCloserWrapper(r io.Writer, closer func() error) io.WriteCloser {
|
|
||||||
return &writeCloserWrapper{
|
|
||||||
Writer: r,
|
|
||||||
closer: closer,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,27 +0,0 @@
|
||||||
Copyright (c) 2014-2015 The Docker & Go Authors. All rights reserved.
|
|
||||||
|
|
||||||
Redistribution and use in source and binary forms, with or without
|
|
||||||
modification, are permitted provided that the following conditions are
|
|
||||||
met:
|
|
||||||
|
|
||||||
* Redistributions of source code must retain the above copyright
|
|
||||||
notice, this list of conditions and the following disclaimer.
|
|
||||||
* Redistributions in binary form must reproduce the above
|
|
||||||
copyright notice, this list of conditions and the following disclaimer
|
|
||||||
in the documentation and/or other materials provided with the
|
|
||||||
distribution.
|
|
||||||
* Neither the name of Google Inc. nor the names of its
|
|
||||||
contributors may be used to endorse or promote products derived from
|
|
||||||
this software without specific prior written permission.
|
|
||||||
|
|
||||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
Victor Vieux <vieux@docker.com> (@vieux)
|
|
||||||
|
|
@ -1,40 +0,0 @@
|
||||||
Package mflag (aka multiple-flag) implements command-line flag parsing.
|
|
||||||
It's an **hacky** fork of the [official golang package](http://golang.org/pkg/flag/)
|
|
||||||
|
|
||||||
It adds:
|
|
||||||
|
|
||||||
* both short and long flag version
|
|
||||||
`./example -s red` `./example --string blue`
|
|
||||||
|
|
||||||
* multiple names for the same option
|
|
||||||
```
|
|
||||||
$>./example -h
|
|
||||||
Usage of example:
|
|
||||||
-s, --string="": a simple string
|
|
||||||
```
|
|
||||||
|
|
||||||
___
|
|
||||||
It is very flexible on purpose, so you can do things like:
|
|
||||||
```
|
|
||||||
$>./example -h
|
|
||||||
Usage of example:
|
|
||||||
-s, -string, --string="": a simple string
|
|
||||||
```
|
|
||||||
|
|
||||||
Or:
|
|
||||||
```
|
|
||||||
$>./example -h
|
|
||||||
Usage of example:
|
|
||||||
-oldflag, --newflag="": a simple string
|
|
||||||
```
|
|
||||||
|
|
||||||
You can also hide some flags from the usage, so if we want only `--newflag`:
|
|
||||||
```
|
|
||||||
$>./example -h
|
|
||||||
Usage of example:
|
|
||||||
--newflag="": a simple string
|
|
||||||
$>./example -oldflag str
|
|
||||||
str
|
|
||||||
```
|
|
||||||
|
|
||||||
See [example.go](example/example.go) for more details.
|
|
||||||
|
|
@ -1,36 +0,0 @@
|
||||||
package main
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
|
|
||||||
flag "github.com/docker/docker/pkg/mflag"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
i int
|
|
||||||
str string
|
|
||||||
b, b2, h bool
|
|
||||||
)
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
flag.Bool([]string{"#hp", "#-halp"}, false, "display the halp")
|
|
||||||
flag.BoolVar(&b, []string{"b", "#bal", "#bol", "-bal"}, false, "a simple bool")
|
|
||||||
flag.BoolVar(&b, []string{"g", "#gil"}, false, "a simple bool")
|
|
||||||
flag.BoolVar(&b2, []string{"#-bool"}, false, "a simple bool")
|
|
||||||
flag.IntVar(&i, []string{"-integer", "-number"}, -1, "a simple integer")
|
|
||||||
flag.StringVar(&str, []string{"s", "#hidden", "-string"}, "", "a simple string") //-s -hidden and --string will work, but -hidden won't be in the usage
|
|
||||||
flag.BoolVar(&h, []string{"h", "#help", "-help"}, false, "display the help")
|
|
||||||
flag.StringVar(&str, []string{"mode"}, "mode1", "set the mode\nmode1: use the mode1\nmode2: use the mode2\nmode3: use the mode3")
|
|
||||||
flag.Parse()
|
|
||||||
}
|
|
||||||
func main() {
|
|
||||||
if h {
|
|
||||||
flag.PrintDefaults()
|
|
||||||
} else {
|
|
||||||
fmt.Printf("s/#hidden/-string: %s\n", str)
|
|
||||||
fmt.Printf("b: %t\n", b)
|
|
||||||
fmt.Printf("-bool: %t\n", b2)
|
|
||||||
fmt.Printf("s/#hidden/-string(via lookup): %s\n", flag.Lookup("s").Value.String())
|
|
||||||
fmt.Printf("ARGS: %v\n", flag.Args())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,516 +0,0 @@
|
||||||
// Copyright 2014-2015 The Docker & Go Authors. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package mflag
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"sort"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// ResetForTesting clears all flag state and sets the usage function as directed.
|
|
||||||
// After calling ResetForTesting, parse errors in flag handling will not
|
|
||||||
// exit the program.
|
|
||||||
func ResetForTesting(usage func()) {
|
|
||||||
CommandLine = NewFlagSet(os.Args[0], ContinueOnError)
|
|
||||||
Usage = usage
|
|
||||||
}
|
|
||||||
func boolString(s string) string {
|
|
||||||
if s == "0" {
|
|
||||||
return "false"
|
|
||||||
}
|
|
||||||
return "true"
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEverything(t *testing.T) {
|
|
||||||
ResetForTesting(nil)
|
|
||||||
Bool([]string{"test_bool"}, false, "bool value")
|
|
||||||
Int([]string{"test_int"}, 0, "int value")
|
|
||||||
Int64([]string{"test_int64"}, 0, "int64 value")
|
|
||||||
Uint([]string{"test_uint"}, 0, "uint value")
|
|
||||||
Uint64([]string{"test_uint64"}, 0, "uint64 value")
|
|
||||||
String([]string{"test_string"}, "0", "string value")
|
|
||||||
Float64([]string{"test_float64"}, 0, "float64 value")
|
|
||||||
Duration([]string{"test_duration"}, 0, "time.Duration value")
|
|
||||||
|
|
||||||
m := make(map[string]*Flag)
|
|
||||||
desired := "0"
|
|
||||||
visitor := func(f *Flag) {
|
|
||||||
for _, name := range f.Names {
|
|
||||||
if len(name) > 5 && name[0:5] == "test_" {
|
|
||||||
m[name] = f
|
|
||||||
ok := false
|
|
||||||
switch {
|
|
||||||
case f.Value.String() == desired:
|
|
||||||
ok = true
|
|
||||||
case name == "test_bool" && f.Value.String() == boolString(desired):
|
|
||||||
ok = true
|
|
||||||
case name == "test_duration" && f.Value.String() == desired+"s":
|
|
||||||
ok = true
|
|
||||||
}
|
|
||||||
if !ok {
|
|
||||||
t.Error("Visit: bad value", f.Value.String(), "for", name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
VisitAll(visitor)
|
|
||||||
if len(m) != 8 {
|
|
||||||
t.Error("VisitAll misses some flags")
|
|
||||||
for k, v := range m {
|
|
||||||
t.Log(k, *v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
m = make(map[string]*Flag)
|
|
||||||
Visit(visitor)
|
|
||||||
if len(m) != 0 {
|
|
||||||
t.Errorf("Visit sees unset flags")
|
|
||||||
for k, v := range m {
|
|
||||||
t.Log(k, *v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// Now set all flags
|
|
||||||
Set("test_bool", "true")
|
|
||||||
Set("test_int", "1")
|
|
||||||
Set("test_int64", "1")
|
|
||||||
Set("test_uint", "1")
|
|
||||||
Set("test_uint64", "1")
|
|
||||||
Set("test_string", "1")
|
|
||||||
Set("test_float64", "1")
|
|
||||||
Set("test_duration", "1s")
|
|
||||||
desired = "1"
|
|
||||||
Visit(visitor)
|
|
||||||
if len(m) != 8 {
|
|
||||||
t.Error("Visit fails after set")
|
|
||||||
for k, v := range m {
|
|
||||||
t.Log(k, *v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// Now test they're visited in sort order.
|
|
||||||
var flagNames []string
|
|
||||||
Visit(func(f *Flag) {
|
|
||||||
for _, name := range f.Names {
|
|
||||||
flagNames = append(flagNames, name)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
if !sort.StringsAreSorted(flagNames) {
|
|
||||||
t.Errorf("flag names not sorted: %v", flagNames)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGet(t *testing.T) {
|
|
||||||
ResetForTesting(nil)
|
|
||||||
Bool([]string{"test_bool"}, true, "bool value")
|
|
||||||
Int([]string{"test_int"}, 1, "int value")
|
|
||||||
Int64([]string{"test_int64"}, 2, "int64 value")
|
|
||||||
Uint([]string{"test_uint"}, 3, "uint value")
|
|
||||||
Uint64([]string{"test_uint64"}, 4, "uint64 value")
|
|
||||||
String([]string{"test_string"}, "5", "string value")
|
|
||||||
Float64([]string{"test_float64"}, 6, "float64 value")
|
|
||||||
Duration([]string{"test_duration"}, 7, "time.Duration value")
|
|
||||||
|
|
||||||
visitor := func(f *Flag) {
|
|
||||||
for _, name := range f.Names {
|
|
||||||
if len(name) > 5 && name[0:5] == "test_" {
|
|
||||||
g, ok := f.Value.(Getter)
|
|
||||||
if !ok {
|
|
||||||
t.Errorf("Visit: value does not satisfy Getter: %T", f.Value)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
switch name {
|
|
||||||
case "test_bool":
|
|
||||||
ok = g.Get() == true
|
|
||||||
case "test_int":
|
|
||||||
ok = g.Get() == int(1)
|
|
||||||
case "test_int64":
|
|
||||||
ok = g.Get() == int64(2)
|
|
||||||
case "test_uint":
|
|
||||||
ok = g.Get() == uint(3)
|
|
||||||
case "test_uint64":
|
|
||||||
ok = g.Get() == uint64(4)
|
|
||||||
case "test_string":
|
|
||||||
ok = g.Get() == "5"
|
|
||||||
case "test_float64":
|
|
||||||
ok = g.Get() == float64(6)
|
|
||||||
case "test_duration":
|
|
||||||
ok = g.Get() == time.Duration(7)
|
|
||||||
}
|
|
||||||
if !ok {
|
|
||||||
t.Errorf("Visit: bad value %T(%v) for %s", g.Get(), g.Get(), name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
VisitAll(visitor)
|
|
||||||
}
|
|
||||||
|
|
||||||
func testParse(f *FlagSet, t *testing.T) {
|
|
||||||
if f.Parsed() {
|
|
||||||
t.Error("f.Parse() = true before Parse")
|
|
||||||
}
|
|
||||||
boolFlag := f.Bool([]string{"bool"}, false, "bool value")
|
|
||||||
bool2Flag := f.Bool([]string{"bool2"}, false, "bool2 value")
|
|
||||||
f.Bool([]string{"bool3"}, false, "bool3 value")
|
|
||||||
bool4Flag := f.Bool([]string{"bool4"}, false, "bool4 value")
|
|
||||||
intFlag := f.Int([]string{"-int"}, 0, "int value")
|
|
||||||
int64Flag := f.Int64([]string{"-int64"}, 0, "int64 value")
|
|
||||||
uintFlag := f.Uint([]string{"uint"}, 0, "uint value")
|
|
||||||
uint64Flag := f.Uint64([]string{"-uint64"}, 0, "uint64 value")
|
|
||||||
stringFlag := f.String([]string{"string"}, "0", "string value")
|
|
||||||
f.String([]string{"string2"}, "0", "string2 value")
|
|
||||||
singleQuoteFlag := f.String([]string{"squote"}, "", "single quoted value")
|
|
||||||
doubleQuoteFlag := f.String([]string{"dquote"}, "", "double quoted value")
|
|
||||||
mixedQuoteFlag := f.String([]string{"mquote"}, "", "mixed quoted value")
|
|
||||||
mixed2QuoteFlag := f.String([]string{"mquote2"}, "", "mixed2 quoted value")
|
|
||||||
nestedQuoteFlag := f.String([]string{"nquote"}, "", "nested quoted value")
|
|
||||||
nested2QuoteFlag := f.String([]string{"nquote2"}, "", "nested2 quoted value")
|
|
||||||
float64Flag := f.Float64([]string{"float64"}, 0, "float64 value")
|
|
||||||
durationFlag := f.Duration([]string{"duration"}, 5*time.Second, "time.Duration value")
|
|
||||||
extra := "one-extra-argument"
|
|
||||||
args := []string{
|
|
||||||
"-bool",
|
|
||||||
"-bool2=true",
|
|
||||||
"-bool4=false",
|
|
||||||
"--int", "22",
|
|
||||||
"--int64", "0x23",
|
|
||||||
"-uint", "24",
|
|
||||||
"--uint64", "25",
|
|
||||||
"-string", "hello",
|
|
||||||
"-squote='single'",
|
|
||||||
`-dquote="double"`,
|
|
||||||
`-mquote='mixed"`,
|
|
||||||
`-mquote2="mixed2'`,
|
|
||||||
`-nquote="'single nested'"`,
|
|
||||||
`-nquote2='"double nested"'`,
|
|
||||||
"-float64", "2718e28",
|
|
||||||
"-duration", "2m",
|
|
||||||
extra,
|
|
||||||
}
|
|
||||||
if err := f.Parse(args); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if !f.Parsed() {
|
|
||||||
t.Error("f.Parse() = false after Parse")
|
|
||||||
}
|
|
||||||
if *boolFlag != true {
|
|
||||||
t.Error("bool flag should be true, is ", *boolFlag)
|
|
||||||
}
|
|
||||||
if *bool2Flag != true {
|
|
||||||
t.Error("bool2 flag should be true, is ", *bool2Flag)
|
|
||||||
}
|
|
||||||
if !f.IsSet("bool2") {
|
|
||||||
t.Error("bool2 should be marked as set")
|
|
||||||
}
|
|
||||||
if f.IsSet("bool3") {
|
|
||||||
t.Error("bool3 should not be marked as set")
|
|
||||||
}
|
|
||||||
if !f.IsSet("bool4") {
|
|
||||||
t.Error("bool4 should be marked as set")
|
|
||||||
}
|
|
||||||
if *bool4Flag != false {
|
|
||||||
t.Error("bool4 flag should be false, is ", *bool4Flag)
|
|
||||||
}
|
|
||||||
if *intFlag != 22 {
|
|
||||||
t.Error("int flag should be 22, is ", *intFlag)
|
|
||||||
}
|
|
||||||
if *int64Flag != 0x23 {
|
|
||||||
t.Error("int64 flag should be 0x23, is ", *int64Flag)
|
|
||||||
}
|
|
||||||
if *uintFlag != 24 {
|
|
||||||
t.Error("uint flag should be 24, is ", *uintFlag)
|
|
||||||
}
|
|
||||||
if *uint64Flag != 25 {
|
|
||||||
t.Error("uint64 flag should be 25, is ", *uint64Flag)
|
|
||||||
}
|
|
||||||
if *stringFlag != "hello" {
|
|
||||||
t.Error("string flag should be `hello`, is ", *stringFlag)
|
|
||||||
}
|
|
||||||
if !f.IsSet("string") {
|
|
||||||
t.Error("string flag should be marked as set")
|
|
||||||
}
|
|
||||||
if f.IsSet("string2") {
|
|
||||||
t.Error("string2 flag should not be marked as set")
|
|
||||||
}
|
|
||||||
if *singleQuoteFlag != "single" {
|
|
||||||
t.Error("single quote string flag should be `single`, is ", *singleQuoteFlag)
|
|
||||||
}
|
|
||||||
if *doubleQuoteFlag != "double" {
|
|
||||||
t.Error("double quote string flag should be `double`, is ", *doubleQuoteFlag)
|
|
||||||
}
|
|
||||||
if *mixedQuoteFlag != `'mixed"` {
|
|
||||||
t.Error("mixed quote string flag should be `'mixed\"`, is ", *mixedQuoteFlag)
|
|
||||||
}
|
|
||||||
if *mixed2QuoteFlag != `"mixed2'` {
|
|
||||||
t.Error("mixed2 quote string flag should be `\"mixed2'`, is ", *mixed2QuoteFlag)
|
|
||||||
}
|
|
||||||
if *nestedQuoteFlag != "'single nested'" {
|
|
||||||
t.Error("nested quote string flag should be `'single nested'`, is ", *nestedQuoteFlag)
|
|
||||||
}
|
|
||||||
if *nested2QuoteFlag != `"double nested"` {
|
|
||||||
t.Error("double quote string flag should be `\"double nested\"`, is ", *nested2QuoteFlag)
|
|
||||||
}
|
|
||||||
if *float64Flag != 2718e28 {
|
|
||||||
t.Error("float64 flag should be 2718e28, is ", *float64Flag)
|
|
||||||
}
|
|
||||||
if *durationFlag != 2*time.Minute {
|
|
||||||
t.Error("duration flag should be 2m, is ", *durationFlag)
|
|
||||||
}
|
|
||||||
if len(f.Args()) != 1 {
|
|
||||||
t.Error("expected one argument, got", len(f.Args()))
|
|
||||||
} else if f.Args()[0] != extra {
|
|
||||||
t.Errorf("expected argument %q got %q", extra, f.Args()[0])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func testPanic(f *FlagSet, t *testing.T) {
|
|
||||||
f.Int([]string{"-int"}, 0, "int value")
|
|
||||||
if f.Parsed() {
|
|
||||||
t.Error("f.Parse() = true before Parse")
|
|
||||||
}
|
|
||||||
args := []string{
|
|
||||||
"-int", "21",
|
|
||||||
}
|
|
||||||
f.Parse(args)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParsePanic(t *testing.T) {
|
|
||||||
ResetForTesting(func() {})
|
|
||||||
testPanic(CommandLine, t)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParse(t *testing.T) {
|
|
||||||
ResetForTesting(func() { t.Error("bad parse") })
|
|
||||||
testParse(CommandLine, t)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestFlagSetParse(t *testing.T) {
|
|
||||||
testParse(NewFlagSet("test", ContinueOnError), t)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Declare a user-defined flag type.
|
|
||||||
type flagVar []string
|
|
||||||
|
|
||||||
func (f *flagVar) String() string {
|
|
||||||
return fmt.Sprint([]string(*f))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *flagVar) Set(value string) error {
|
|
||||||
*f = append(*f, value)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestUserDefined(t *testing.T) {
|
|
||||||
var flags FlagSet
|
|
||||||
flags.Init("test", ContinueOnError)
|
|
||||||
var v flagVar
|
|
||||||
flags.Var(&v, []string{"v"}, "usage")
|
|
||||||
if err := flags.Parse([]string{"-v", "1", "-v", "2", "-v=3"}); err != nil {
|
|
||||||
t.Error(err)
|
|
||||||
}
|
|
||||||
if len(v) != 3 {
|
|
||||||
t.Fatal("expected 3 args; got ", len(v))
|
|
||||||
}
|
|
||||||
expect := "[1 2 3]"
|
|
||||||
if v.String() != expect {
|
|
||||||
t.Errorf("expected value %q got %q", expect, v.String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Declare a user-defined boolean flag type.
|
|
||||||
type boolFlagVar struct {
|
|
||||||
count int
|
|
||||||
}
|
|
||||||
|
|
||||||
func (b *boolFlagVar) String() string {
|
|
||||||
return fmt.Sprintf("%d", b.count)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (b *boolFlagVar) Set(value string) error {
|
|
||||||
if value == "true" {
|
|
||||||
b.count++
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (b *boolFlagVar) IsBoolFlag() bool {
|
|
||||||
return b.count < 4
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestUserDefinedBool(t *testing.T) {
|
|
||||||
var flags FlagSet
|
|
||||||
flags.Init("test", ContinueOnError)
|
|
||||||
var b boolFlagVar
|
|
||||||
var err error
|
|
||||||
flags.Var(&b, []string{"b"}, "usage")
|
|
||||||
if err = flags.Parse([]string{"-b", "-b", "-b", "-b=true", "-b=false", "-b", "barg", "-b"}); err != nil {
|
|
||||||
if b.count < 4 {
|
|
||||||
t.Error(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if b.count != 4 {
|
|
||||||
t.Errorf("want: %d; got: %d", 4, b.count)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err == nil {
|
|
||||||
t.Error("expected error; got none")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSetOutput(t *testing.T) {
|
|
||||||
var flags FlagSet
|
|
||||||
var buf bytes.Buffer
|
|
||||||
flags.SetOutput(&buf)
|
|
||||||
flags.Init("test", ContinueOnError)
|
|
||||||
flags.Parse([]string{"-unknown"})
|
|
||||||
if out := buf.String(); !strings.Contains(out, "-unknown") {
|
|
||||||
t.Logf("expected output mentioning unknown; got %q", out)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// This tests that one can reset the flags. This still works but not well, and is
|
|
||||||
// superseded by FlagSet.
|
|
||||||
func TestChangingArgs(t *testing.T) {
|
|
||||||
ResetForTesting(func() { t.Fatal("bad parse") })
|
|
||||||
oldArgs := os.Args
|
|
||||||
defer func() { os.Args = oldArgs }()
|
|
||||||
os.Args = []string{"cmd", "-before", "subcmd", "-after", "args"}
|
|
||||||
before := Bool([]string{"before"}, false, "")
|
|
||||||
if err := CommandLine.Parse(os.Args[1:]); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
cmd := Arg(0)
|
|
||||||
os.Args = Args()
|
|
||||||
after := Bool([]string{"after"}, false, "")
|
|
||||||
Parse()
|
|
||||||
args := Args()
|
|
||||||
|
|
||||||
if !*before || cmd != "subcmd" || !*after || len(args) != 1 || args[0] != "args" {
|
|
||||||
t.Fatalf("expected true subcmd true [args] got %v %v %v %v", *before, cmd, *after, args)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test that -help invokes the usage message and returns ErrHelp.
|
|
||||||
func TestHelp(t *testing.T) {
|
|
||||||
var helpCalled = false
|
|
||||||
fs := NewFlagSet("help test", ContinueOnError)
|
|
||||||
fs.Usage = func() { helpCalled = true }
|
|
||||||
var flag bool
|
|
||||||
fs.BoolVar(&flag, []string{"flag"}, false, "regular flag")
|
|
||||||
// Regular flag invocation should work
|
|
||||||
err := fs.Parse([]string{"-flag=true"})
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal("expected no error; got ", err)
|
|
||||||
}
|
|
||||||
if !flag {
|
|
||||||
t.Error("flag was not set by -flag")
|
|
||||||
}
|
|
||||||
if helpCalled {
|
|
||||||
t.Error("help called for regular flag")
|
|
||||||
helpCalled = false // reset for next test
|
|
||||||
}
|
|
||||||
// Help flag should work as expected.
|
|
||||||
err = fs.Parse([]string{"-help"})
|
|
||||||
if err == nil {
|
|
||||||
t.Fatal("error expected")
|
|
||||||
}
|
|
||||||
if err != ErrHelp {
|
|
||||||
t.Fatal("expected ErrHelp; got ", err)
|
|
||||||
}
|
|
||||||
if !helpCalled {
|
|
||||||
t.Fatal("help was not called")
|
|
||||||
}
|
|
||||||
// If we define a help flag, that should override.
|
|
||||||
var help bool
|
|
||||||
fs.BoolVar(&help, []string{"help"}, false, "help flag")
|
|
||||||
helpCalled = false
|
|
||||||
err = fs.Parse([]string{"-help"})
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal("expected no error for defined -help; got ", err)
|
|
||||||
}
|
|
||||||
if helpCalled {
|
|
||||||
t.Fatal("help was called; should not have been for defined help flag")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test the flag count functions.
|
|
||||||
func TestFlagCounts(t *testing.T) {
|
|
||||||
fs := NewFlagSet("help test", ContinueOnError)
|
|
||||||
var flag bool
|
|
||||||
fs.BoolVar(&flag, []string{"flag1"}, false, "regular flag")
|
|
||||||
fs.BoolVar(&flag, []string{"#deprecated1"}, false, "regular flag")
|
|
||||||
fs.BoolVar(&flag, []string{"f", "flag2"}, false, "regular flag")
|
|
||||||
fs.BoolVar(&flag, []string{"#d", "#deprecated2"}, false, "regular flag")
|
|
||||||
fs.BoolVar(&flag, []string{"flag3"}, false, "regular flag")
|
|
||||||
fs.BoolVar(&flag, []string{"g", "#flag4", "-flag4"}, false, "regular flag")
|
|
||||||
|
|
||||||
if fs.FlagCount() != 6 {
|
|
||||||
t.Fatal("FlagCount wrong. ", fs.FlagCount())
|
|
||||||
}
|
|
||||||
if fs.FlagCountUndeprecated() != 4 {
|
|
||||||
t.Fatal("FlagCountUndeprecated wrong. ", fs.FlagCountUndeprecated())
|
|
||||||
}
|
|
||||||
if fs.NFlag() != 0 {
|
|
||||||
t.Fatal("NFlag wrong. ", fs.NFlag())
|
|
||||||
}
|
|
||||||
err := fs.Parse([]string{"-fd", "-g", "-flag4"})
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal("expected no error for defined -help; got ", err)
|
|
||||||
}
|
|
||||||
if fs.NFlag() != 4 {
|
|
||||||
t.Fatal("NFlag wrong. ", fs.NFlag())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Show up bug in sortFlags
|
|
||||||
func TestSortFlags(t *testing.T) {
|
|
||||||
fs := NewFlagSet("help TestSortFlags", ContinueOnError)
|
|
||||||
|
|
||||||
var err error
|
|
||||||
|
|
||||||
var b bool
|
|
||||||
fs.BoolVar(&b, []string{"b", "-banana"}, false, "usage")
|
|
||||||
|
|
||||||
err = fs.Parse([]string{"--banana=true"})
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal("expected no error; got ", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
count := 0
|
|
||||||
|
|
||||||
fs.VisitAll(func(flag *Flag) {
|
|
||||||
count++
|
|
||||||
if flag == nil {
|
|
||||||
t.Fatal("VisitAll should not return a nil flag")
|
|
||||||
}
|
|
||||||
})
|
|
||||||
flagcount := fs.FlagCount()
|
|
||||||
if flagcount != count {
|
|
||||||
t.Fatalf("FlagCount (%d) != number (%d) of elements visited", flagcount, count)
|
|
||||||
}
|
|
||||||
// Make sure its idempotent
|
|
||||||
if flagcount != fs.FlagCount() {
|
|
||||||
t.Fatalf("FlagCount (%d) != fs.FlagCount() (%d) of elements visited", flagcount, fs.FlagCount())
|
|
||||||
}
|
|
||||||
|
|
||||||
count = 0
|
|
||||||
fs.Visit(func(flag *Flag) {
|
|
||||||
count++
|
|
||||||
if flag == nil {
|
|
||||||
t.Fatal("Visit should not return a nil flag")
|
|
||||||
}
|
|
||||||
})
|
|
||||||
nflag := fs.NFlag()
|
|
||||||
if nflag != count {
|
|
||||||
t.Fatalf("NFlag (%d) != number (%d) of elements visited", nflag, count)
|
|
||||||
}
|
|
||||||
if nflag != fs.NFlag() {
|
|
||||||
t.Fatalf("NFlag (%d) != fs.NFlag() (%d) of elements visited", nflag, fs.NFlag())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
Erik Hollensbe <github@hollensbe.org> (@erikh)
|
|
||||||
|
|
@ -1,85 +0,0 @@
|
||||||
package filters
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/json"
|
|
||||||
"errors"
|
|
||||||
"regexp"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Args map[string][]string
|
|
||||||
|
|
||||||
// Parse the argument to the filter flag. Like
|
|
||||||
//
|
|
||||||
// `docker ps -f 'created=today' -f 'image.name=ubuntu*'`
|
|
||||||
//
|
|
||||||
// If prev map is provided, then it is appended to, and returned. By default a new
|
|
||||||
// map is created.
|
|
||||||
func ParseFlag(arg string, prev Args) (Args, error) {
|
|
||||||
var filters Args = prev
|
|
||||||
if prev == nil {
|
|
||||||
filters = Args{}
|
|
||||||
}
|
|
||||||
if len(arg) == 0 {
|
|
||||||
return filters, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if !strings.Contains(arg, "=") {
|
|
||||||
return filters, ErrorBadFormat
|
|
||||||
}
|
|
||||||
|
|
||||||
f := strings.SplitN(arg, "=", 2)
|
|
||||||
name := strings.ToLower(strings.TrimSpace(f[0]))
|
|
||||||
value := strings.TrimSpace(f[1])
|
|
||||||
filters[name] = append(filters[name], value)
|
|
||||||
|
|
||||||
return filters, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
var ErrorBadFormat = errors.New("bad format of filter (expected name=value)")
|
|
||||||
|
|
||||||
// packs the Args into an string for easy transport from client to server
|
|
||||||
func ToParam(a Args) (string, error) {
|
|
||||||
// this way we don't URL encode {}, just empty space
|
|
||||||
if len(a) == 0 {
|
|
||||||
return "", nil
|
|
||||||
}
|
|
||||||
|
|
||||||
buf, err := json.Marshal(a)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
return string(buf), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// unpacks the filter Args
|
|
||||||
func FromParam(p string) (Args, error) {
|
|
||||||
args := Args{}
|
|
||||||
if len(p) == 0 {
|
|
||||||
return args, nil
|
|
||||||
}
|
|
||||||
err := json.Unmarshal([]byte(p), &args)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return args, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (filters Args) Match(field, source string) bool {
|
|
||||||
fieldValues := filters[field]
|
|
||||||
|
|
||||||
//do not filter if there is no filter set or cannot determine filter
|
|
||||||
if len(fieldValues) == 0 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
for _, name2match := range fieldValues {
|
|
||||||
match, err := regexp.MatchString(name2match, source)
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if match {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
78
Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/filters/parse_test.go
generated
vendored
78
Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/filters/parse_test.go
generated
vendored
|
|
@ -1,78 +0,0 @@
|
||||||
package filters
|
|
||||||
|
|
||||||
import (
|
|
||||||
"sort"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestParseArgs(t *testing.T) {
|
|
||||||
// equivalent of `docker ps -f 'created=today' -f 'image.name=ubuntu*' -f 'image.name=*untu'`
|
|
||||||
flagArgs := []string{
|
|
||||||
"created=today",
|
|
||||||
"image.name=ubuntu*",
|
|
||||||
"image.name=*untu",
|
|
||||||
}
|
|
||||||
var (
|
|
||||||
args = Args{}
|
|
||||||
err error
|
|
||||||
)
|
|
||||||
for i := range flagArgs {
|
|
||||||
args, err = ParseFlag(flagArgs[i], args)
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("failed to parse %s: %s", flagArgs[i], err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(args["created"]) != 1 {
|
|
||||||
t.Errorf("failed to set this arg")
|
|
||||||
}
|
|
||||||
if len(args["image.name"]) != 2 {
|
|
||||||
t.Errorf("the args should have collapsed")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParam(t *testing.T) {
|
|
||||||
a := Args{
|
|
||||||
"created": []string{"today"},
|
|
||||||
"image.name": []string{"ubuntu*", "*untu"},
|
|
||||||
}
|
|
||||||
|
|
||||||
v, err := ToParam(a)
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("failed to marshal the filters: %s", err)
|
|
||||||
}
|
|
||||||
v1, err := FromParam(v)
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("%s", err)
|
|
||||||
}
|
|
||||||
for key, vals := range v1 {
|
|
||||||
if _, ok := a[key]; !ok {
|
|
||||||
t.Errorf("could not find key %s in original set", key)
|
|
||||||
}
|
|
||||||
sort.Strings(vals)
|
|
||||||
sort.Strings(a[key])
|
|
||||||
if len(vals) != len(a[key]) {
|
|
||||||
t.Errorf("value lengths ought to match")
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
for i := range vals {
|
|
||||||
if vals[i] != a[key][i] {
|
|
||||||
t.Errorf("expected %s, but got %s", a[key][i], vals[i])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEmpty(t *testing.T) {
|
|
||||||
a := Args{}
|
|
||||||
v, err := ToParam(a)
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("failed to marshal the filters: %s", err)
|
|
||||||
}
|
|
||||||
v1, err := FromParam(v)
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("%s", err)
|
|
||||||
}
|
|
||||||
if len(a) != len(v1) {
|
|
||||||
t.Errorf("these should both be empty sets")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,93 +0,0 @@
|
||||||
package kernel
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
)
|
|
||||||
|
|
||||||
type KernelVersionInfo struct {
|
|
||||||
Kernel int
|
|
||||||
Major int
|
|
||||||
Minor int
|
|
||||||
Flavor string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (k *KernelVersionInfo) String() string {
|
|
||||||
return fmt.Sprintf("%d.%d.%d%s", k.Kernel, k.Major, k.Minor, k.Flavor)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Compare two KernelVersionInfo struct.
|
|
||||||
// Returns -1 if a < b, 0 if a == b, 1 it a > b
|
|
||||||
func CompareKernelVersion(a, b *KernelVersionInfo) int {
|
|
||||||
if a.Kernel < b.Kernel {
|
|
||||||
return -1
|
|
||||||
} else if a.Kernel > b.Kernel {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
|
|
||||||
if a.Major < b.Major {
|
|
||||||
return -1
|
|
||||||
} else if a.Major > b.Major {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
|
|
||||||
if a.Minor < b.Minor {
|
|
||||||
return -1
|
|
||||||
} else if a.Minor > b.Minor {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func GetKernelVersion() (*KernelVersionInfo, error) {
|
|
||||||
var (
|
|
||||||
err error
|
|
||||||
)
|
|
||||||
|
|
||||||
uts, err := uname()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
release := make([]byte, len(uts.Release))
|
|
||||||
|
|
||||||
i := 0
|
|
||||||
for _, c := range uts.Release {
|
|
||||||
release[i] = byte(c)
|
|
||||||
i++
|
|
||||||
}
|
|
||||||
|
|
||||||
// Remove the \x00 from the release for Atoi to parse correctly
|
|
||||||
release = release[:bytes.IndexByte(release, 0)]
|
|
||||||
|
|
||||||
return ParseRelease(string(release))
|
|
||||||
}
|
|
||||||
|
|
||||||
func ParseRelease(release string) (*KernelVersionInfo, error) {
|
|
||||||
var (
|
|
||||||
kernel, major, minor, parsed int
|
|
||||||
flavor, partial string
|
|
||||||
)
|
|
||||||
|
|
||||||
// Ignore error from Sscanf to allow an empty flavor. Instead, just
|
|
||||||
// make sure we got all the version numbers.
|
|
||||||
parsed, _ = fmt.Sscanf(release, "%d.%d%s", &kernel, &major, &partial)
|
|
||||||
if parsed < 2 {
|
|
||||||
return nil, errors.New("Can't parse kernel version " + release)
|
|
||||||
}
|
|
||||||
|
|
||||||
// sometimes we have 3.12.25-gentoo, but sometimes we just have 3.12-1-amd64
|
|
||||||
parsed, _ = fmt.Sscanf(partial, ".%d%s", &minor, &flavor)
|
|
||||||
if parsed < 1 {
|
|
||||||
flavor = partial
|
|
||||||
}
|
|
||||||
|
|
||||||
return &KernelVersionInfo{
|
|
||||||
Kernel: kernel,
|
|
||||||
Major: major,
|
|
||||||
Minor: minor,
|
|
||||||
Flavor: flavor,
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
61
Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/kernel/kernel_test.go
generated
vendored
61
Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/kernel/kernel_test.go
generated
vendored
|
|
@ -1,61 +0,0 @@
|
||||||
package kernel
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func assertParseRelease(t *testing.T, release string, b *KernelVersionInfo, result int) {
|
|
||||||
var (
|
|
||||||
a *KernelVersionInfo
|
|
||||||
)
|
|
||||||
a, _ = ParseRelease(release)
|
|
||||||
|
|
||||||
if r := CompareKernelVersion(a, b); r != result {
|
|
||||||
t.Fatalf("Unexpected kernel version comparison result. Found %d, expected %d", r, result)
|
|
||||||
}
|
|
||||||
if a.Flavor != b.Flavor {
|
|
||||||
t.Fatalf("Unexpected parsed kernel flavor. Found %s, expected %s", a.Flavor, b.Flavor)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseRelease(t *testing.T) {
|
|
||||||
assertParseRelease(t, "3.8.0", &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0}, 0)
|
|
||||||
assertParseRelease(t, "3.4.54.longterm-1", &KernelVersionInfo{Kernel: 3, Major: 4, Minor: 54, Flavor: ".longterm-1"}, 0)
|
|
||||||
assertParseRelease(t, "3.4.54.longterm-1", &KernelVersionInfo{Kernel: 3, Major: 4, Minor: 54, Flavor: ".longterm-1"}, 0)
|
|
||||||
assertParseRelease(t, "3.8.0-19-generic", &KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0, Flavor: "-19-generic"}, 0)
|
|
||||||
assertParseRelease(t, "3.12.8tag", &KernelVersionInfo{Kernel: 3, Major: 12, Minor: 8, Flavor: "tag"}, 0)
|
|
||||||
assertParseRelease(t, "3.12-1-amd64", &KernelVersionInfo{Kernel: 3, Major: 12, Minor: 0, Flavor: "-1-amd64"}, 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
func assertKernelVersion(t *testing.T, a, b *KernelVersionInfo, result int) {
|
|
||||||
if r := CompareKernelVersion(a, b); r != result {
|
|
||||||
t.Fatalf("Unexpected kernel version comparison result. Found %d, expected %d", r, result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCompareKernelVersion(t *testing.T) {
|
|
||||||
assertKernelVersion(t,
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
||||||
0)
|
|
||||||
assertKernelVersion(t,
|
|
||||||
&KernelVersionInfo{Kernel: 2, Major: 6, Minor: 0},
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
||||||
-1)
|
|
||||||
assertKernelVersion(t,
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
||||||
&KernelVersionInfo{Kernel: 2, Major: 6, Minor: 0},
|
|
||||||
1)
|
|
||||||
assertKernelVersion(t,
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
||||||
0)
|
|
||||||
assertKernelVersion(t,
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 5},
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
||||||
1)
|
|
||||||
assertKernelVersion(t,
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 0, Minor: 20},
|
|
||||||
&KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0},
|
|
||||||
-1)
|
|
||||||
}
|
|
||||||
16
Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/kernel/uname_linux.go
generated
vendored
16
Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/kernel/uname_linux.go
generated
vendored
|
|
@ -1,16 +0,0 @@
|
||||||
package kernel
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Utsname syscall.Utsname
|
|
||||||
|
|
||||||
func uname() (*syscall.Utsname, error) {
|
|
||||||
uts := &syscall.Utsname{}
|
|
||||||
|
|
||||||
if err := syscall.Uname(uts); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return uts, nil
|
|
||||||
}
|
|
||||||
15
Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/kernel/uname_unsupported.go
generated
vendored
15
Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/kernel/uname_unsupported.go
generated
vendored
|
|
@ -1,15 +0,0 @@
|
||||||
// +build !linux
|
|
||||||
|
|
||||||
package kernel
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Utsname struct {
|
|
||||||
Release [65]byte
|
|
||||||
}
|
|
||||||
|
|
||||||
func uname() (*Utsname, error) {
|
|
||||||
return nil, errors.New("Kernel version detection is available only on linux")
|
|
||||||
}
|
|
||||||
|
|
@ -1,40 +0,0 @@
|
||||||
package operatingsystem
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"errors"
|
|
||||||
"io/ioutil"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
// file to use to detect if the daemon is running in a container
|
|
||||||
proc1Cgroup = "/proc/1/cgroup"
|
|
||||||
|
|
||||||
// file to check to determine Operating System
|
|
||||||
etcOsRelease = "/etc/os-release"
|
|
||||||
)
|
|
||||||
|
|
||||||
func GetOperatingSystem() (string, error) {
|
|
||||||
b, err := ioutil.ReadFile(etcOsRelease)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
if i := bytes.Index(b, []byte("PRETTY_NAME")); i >= 0 {
|
|
||||||
b = b[i+13:]
|
|
||||||
return string(b[:bytes.IndexByte(b, '"')]), nil
|
|
||||||
}
|
|
||||||
return "", errors.New("PRETTY_NAME not found")
|
|
||||||
}
|
|
||||||
|
|
||||||
func IsContainerized() (bool, error) {
|
|
||||||
b, err := ioutil.ReadFile(proc1Cgroup)
|
|
||||||
if err != nil {
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
for _, line := range bytes.Split(b, []byte{'\n'}) {
|
|
||||||
if len(line) > 0 && !bytes.HasSuffix(line, []byte{'/'}) {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,124 +0,0 @@
|
||||||
package operatingsystem
|
|
||||||
|
|
||||||
import (
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestGetOperatingSystem(t *testing.T) {
|
|
||||||
var (
|
|
||||||
backup = etcOsRelease
|
|
||||||
ubuntuTrusty = []byte(`NAME="Ubuntu"
|
|
||||||
VERSION="14.04, Trusty Tahr"
|
|
||||||
ID=ubuntu
|
|
||||||
ID_LIKE=debian
|
|
||||||
PRETTY_NAME="Ubuntu 14.04 LTS"
|
|
||||||
VERSION_ID="14.04"
|
|
||||||
HOME_URL="http://www.ubuntu.com/"
|
|
||||||
SUPPORT_URL="http://help.ubuntu.com/"
|
|
||||||
BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"`)
|
|
||||||
gentoo = []byte(`NAME=Gentoo
|
|
||||||
ID=gentoo
|
|
||||||
PRETTY_NAME="Gentoo/Linux"
|
|
||||||
ANSI_COLOR="1;32"
|
|
||||||
HOME_URL="http://www.gentoo.org/"
|
|
||||||
SUPPORT_URL="http://www.gentoo.org/main/en/support.xml"
|
|
||||||
BUG_REPORT_URL="https://bugs.gentoo.org/"
|
|
||||||
`)
|
|
||||||
noPrettyName = []byte(`NAME="Ubuntu"
|
|
||||||
VERSION="14.04, Trusty Tahr"
|
|
||||||
ID=ubuntu
|
|
||||||
ID_LIKE=debian
|
|
||||||
VERSION_ID="14.04"
|
|
||||||
HOME_URL="http://www.ubuntu.com/"
|
|
||||||
SUPPORT_URL="http://help.ubuntu.com/"
|
|
||||||
BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"`)
|
|
||||||
)
|
|
||||||
|
|
||||||
dir := os.TempDir()
|
|
||||||
etcOsRelease = filepath.Join(dir, "etcOsRelease")
|
|
||||||
|
|
||||||
defer func() {
|
|
||||||
os.Remove(etcOsRelease)
|
|
||||||
etcOsRelease = backup
|
|
||||||
}()
|
|
||||||
|
|
||||||
for expect, osRelease := range map[string][]byte{
|
|
||||||
"Ubuntu 14.04 LTS": ubuntuTrusty,
|
|
||||||
"Gentoo/Linux": gentoo,
|
|
||||||
"": noPrettyName,
|
|
||||||
} {
|
|
||||||
if err := ioutil.WriteFile(etcOsRelease, osRelease, 0600); err != nil {
|
|
||||||
t.Fatalf("failed to write to %s: %v", etcOsRelease, err)
|
|
||||||
}
|
|
||||||
s, err := GetOperatingSystem()
|
|
||||||
if s != expect {
|
|
||||||
if expect == "" {
|
|
||||||
t.Fatalf("Expected error 'PRETTY_NAME not found', but got %v", err)
|
|
||||||
} else {
|
|
||||||
t.Fatalf("Expected '%s', but got '%s'. Err=%v", expect, s, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIsContainerized(t *testing.T) {
|
|
||||||
var (
|
|
||||||
backup = proc1Cgroup
|
|
||||||
nonContainerizedProc1Cgroup = []byte(`14:name=systemd:/
|
|
||||||
13:hugetlb:/
|
|
||||||
12:net_prio:/
|
|
||||||
11:perf_event:/
|
|
||||||
10:bfqio:/
|
|
||||||
9:blkio:/
|
|
||||||
8:net_cls:/
|
|
||||||
7:freezer:/
|
|
||||||
6:devices:/
|
|
||||||
5:memory:/
|
|
||||||
4:cpuacct:/
|
|
||||||
3:cpu:/
|
|
||||||
2:cpuset:/
|
|
||||||
`)
|
|
||||||
containerizedProc1Cgroup = []byte(`9:perf_event:/docker/3cef1b53c50b0fa357d994f8a1a8cd783c76bbf4f5dd08b226e38a8bd331338d
|
|
||||||
8:blkio:/docker/3cef1b53c50b0fa357d994f8a1a8cd783c76bbf4f5dd08b226e38a8bd331338d
|
|
||||||
7:net_cls:/
|
|
||||||
6:freezer:/docker/3cef1b53c50b0fa357d994f8a1a8cd783c76bbf4f5dd08b226e38a8bd331338d
|
|
||||||
5:devices:/docker/3cef1b53c50b0fa357d994f8a1a8cd783c76bbf4f5dd08b226e38a8bd331338d
|
|
||||||
4:memory:/docker/3cef1b53c50b0fa357d994f8a1a8cd783c76bbf4f5dd08b226e38a8bd331338d
|
|
||||||
3:cpuacct:/docker/3cef1b53c50b0fa357d994f8a1a8cd783c76bbf4f5dd08b226e38a8bd331338d
|
|
||||||
2:cpu:/docker/3cef1b53c50b0fa357d994f8a1a8cd783c76bbf4f5dd08b226e38a8bd331338d
|
|
||||||
1:cpuset:/`)
|
|
||||||
)
|
|
||||||
|
|
||||||
dir := os.TempDir()
|
|
||||||
proc1Cgroup = filepath.Join(dir, "proc1Cgroup")
|
|
||||||
|
|
||||||
defer func() {
|
|
||||||
os.Remove(proc1Cgroup)
|
|
||||||
proc1Cgroup = backup
|
|
||||||
}()
|
|
||||||
|
|
||||||
if err := ioutil.WriteFile(proc1Cgroup, nonContainerizedProc1Cgroup, 0600); err != nil {
|
|
||||||
t.Fatalf("failed to write to %s: %v", proc1Cgroup, err)
|
|
||||||
}
|
|
||||||
inContainer, err := IsContainerized()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if inContainer {
|
|
||||||
t.Fatal("Wrongly assuming containerized")
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := ioutil.WriteFile(proc1Cgroup, containerizedProc1Cgroup, 0600); err != nil {
|
|
||||||
t.Fatalf("failed to write to %s: %v", proc1Cgroup, err)
|
|
||||||
}
|
|
||||||
inContainer, err = IsContainerized()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if !inContainer {
|
|
||||||
t.Fatal("Wrongly assuming non-containerized")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,131 +0,0 @@
|
||||||
package parsers
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// FIXME: Change this not to receive default value as parameter
|
|
||||||
func ParseHost(defaultTCPAddr, defaultUnixAddr, addr string) (string, error) {
|
|
||||||
addr = strings.TrimSpace(addr)
|
|
||||||
if addr == "" {
|
|
||||||
addr = fmt.Sprintf("unix://%s", defaultUnixAddr)
|
|
||||||
}
|
|
||||||
addrParts := strings.Split(addr, "://")
|
|
||||||
if len(addrParts) == 1 {
|
|
||||||
addrParts = []string{"tcp", addrParts[0]}
|
|
||||||
}
|
|
||||||
|
|
||||||
switch addrParts[0] {
|
|
||||||
case "tcp":
|
|
||||||
return ParseTCPAddr(addrParts[1], defaultTCPAddr)
|
|
||||||
case "unix":
|
|
||||||
return ParseUnixAddr(addrParts[1], defaultUnixAddr)
|
|
||||||
case "fd":
|
|
||||||
return addr, nil
|
|
||||||
default:
|
|
||||||
return "", fmt.Errorf("Invalid bind address format: %s", addr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func ParseUnixAddr(addr string, defaultAddr string) (string, error) {
|
|
||||||
addr = strings.TrimPrefix(addr, "unix://")
|
|
||||||
if strings.Contains(addr, "://") {
|
|
||||||
return "", fmt.Errorf("Invalid proto, expected unix: %s", addr)
|
|
||||||
}
|
|
||||||
if addr == "" {
|
|
||||||
addr = defaultAddr
|
|
||||||
}
|
|
||||||
return fmt.Sprintf("unix://%s", addr), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func ParseTCPAddr(addr string, defaultAddr string) (string, error) {
|
|
||||||
addr = strings.TrimPrefix(addr, "tcp://")
|
|
||||||
if strings.Contains(addr, "://") || addr == "" {
|
|
||||||
return "", fmt.Errorf("Invalid proto, expected tcp: %s", addr)
|
|
||||||
}
|
|
||||||
|
|
||||||
hostParts := strings.Split(addr, ":")
|
|
||||||
if len(hostParts) != 2 {
|
|
||||||
return "", fmt.Errorf("Invalid bind address format: %s", addr)
|
|
||||||
}
|
|
||||||
host := hostParts[0]
|
|
||||||
if host == "" {
|
|
||||||
host = defaultAddr
|
|
||||||
}
|
|
||||||
|
|
||||||
p, err := strconv.Atoi(hostParts[1])
|
|
||||||
if err != nil && p == 0 {
|
|
||||||
return "", fmt.Errorf("Invalid bind address format: %s", addr)
|
|
||||||
}
|
|
||||||
return fmt.Sprintf("tcp://%s:%d", host, p), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get a repos name and returns the right reposName + tag
|
|
||||||
// The tag can be confusing because of a port in a repository name.
|
|
||||||
// Ex: localhost.localdomain:5000/samalba/hipache:latest
|
|
||||||
func ParseRepositoryTag(repos string) (string, string) {
|
|
||||||
n := strings.LastIndex(repos, ":")
|
|
||||||
if n < 0 {
|
|
||||||
return repos, ""
|
|
||||||
}
|
|
||||||
if tag := repos[n+1:]; !strings.Contains(tag, "/") {
|
|
||||||
return repos[:n], tag
|
|
||||||
}
|
|
||||||
return repos, ""
|
|
||||||
}
|
|
||||||
|
|
||||||
func PartParser(template, data string) (map[string]string, error) {
|
|
||||||
// ip:public:private
|
|
||||||
var (
|
|
||||||
templateParts = strings.Split(template, ":")
|
|
||||||
parts = strings.Split(data, ":")
|
|
||||||
out = make(map[string]string, len(templateParts))
|
|
||||||
)
|
|
||||||
if len(parts) != len(templateParts) {
|
|
||||||
return nil, fmt.Errorf("Invalid format to parse. %s should match template %s", data, template)
|
|
||||||
}
|
|
||||||
|
|
||||||
for i, t := range templateParts {
|
|
||||||
value := ""
|
|
||||||
if len(parts) > i {
|
|
||||||
value = parts[i]
|
|
||||||
}
|
|
||||||
out[t] = value
|
|
||||||
}
|
|
||||||
return out, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func ParseKeyValueOpt(opt string) (string, string, error) {
|
|
||||||
parts := strings.SplitN(opt, "=", 2)
|
|
||||||
if len(parts) != 2 {
|
|
||||||
return "", "", fmt.Errorf("Unable to parse key/value option: %s", opt)
|
|
||||||
}
|
|
||||||
return strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func ParsePortRange(ports string) (uint64, uint64, error) {
|
|
||||||
if ports == "" {
|
|
||||||
return 0, 0, fmt.Errorf("Empty string specified for ports.")
|
|
||||||
}
|
|
||||||
if !strings.Contains(ports, "-") {
|
|
||||||
start, err := strconv.ParseUint(ports, 10, 16)
|
|
||||||
end := start
|
|
||||||
return start, end, err
|
|
||||||
}
|
|
||||||
|
|
||||||
parts := strings.Split(ports, "-")
|
|
||||||
start, err := strconv.ParseUint(parts[0], 10, 16)
|
|
||||||
if err != nil {
|
|
||||||
return 0, 0, err
|
|
||||||
}
|
|
||||||
end, err := strconv.ParseUint(parts[1], 10, 16)
|
|
||||||
if err != nil {
|
|
||||||
return 0, 0, err
|
|
||||||
}
|
|
||||||
if end < start {
|
|
||||||
return 0, 0, fmt.Errorf("Invalid range specified for the Port: %s", ports)
|
|
||||||
}
|
|
||||||
return start, end, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,116 +0,0 @@
|
||||||
package parsers
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestParseHost(t *testing.T) {
|
|
||||||
var (
|
|
||||||
defaultHttpHost = "127.0.0.1"
|
|
||||||
defaultUnix = "/var/run/docker.sock"
|
|
||||||
)
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "0.0.0.0"); err == nil {
|
|
||||||
t.Errorf("tcp 0.0.0.0 address expected error return, but err == nil, got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "tcp://"); err == nil {
|
|
||||||
t.Errorf("default tcp:// address expected error return, but err == nil, got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "0.0.0.1:5555"); err != nil || addr != "tcp://0.0.0.1:5555" {
|
|
||||||
t.Errorf("0.0.0.1:5555 -> expected tcp://0.0.0.1:5555, got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, ":6666"); err != nil || addr != "tcp://127.0.0.1:6666" {
|
|
||||||
t.Errorf(":6666 -> expected tcp://127.0.0.1:6666, got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "tcp://:7777"); err != nil || addr != "tcp://127.0.0.1:7777" {
|
|
||||||
t.Errorf("tcp://:7777 -> expected tcp://127.0.0.1:7777, got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, ""); err != nil || addr != "unix:///var/run/docker.sock" {
|
|
||||||
t.Errorf("empty argument -> expected unix:///var/run/docker.sock, got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "unix:///var/run/docker.sock"); err != nil || addr != "unix:///var/run/docker.sock" {
|
|
||||||
t.Errorf("unix:///var/run/docker.sock -> expected unix:///var/run/docker.sock, got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "unix://"); err != nil || addr != "unix:///var/run/docker.sock" {
|
|
||||||
t.Errorf("unix:///var/run/docker.sock -> expected unix:///var/run/docker.sock, got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "udp://127.0.0.1"); err == nil {
|
|
||||||
t.Errorf("udp protocol address expected error return, but err == nil. Got %s", addr)
|
|
||||||
}
|
|
||||||
if addr, err := ParseHost(defaultHttpHost, defaultUnix, "udp://127.0.0.1:2375"); err == nil {
|
|
||||||
t.Errorf("udp protocol address expected error return, but err == nil. Got %s", addr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseRepositoryTag(t *testing.T) {
|
|
||||||
if repo, tag := ParseRepositoryTag("root"); repo != "root" || tag != "" {
|
|
||||||
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "root", "", repo, tag)
|
|
||||||
}
|
|
||||||
if repo, tag := ParseRepositoryTag("root:tag"); repo != "root" || tag != "tag" {
|
|
||||||
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "root", "tag", repo, tag)
|
|
||||||
}
|
|
||||||
if repo, tag := ParseRepositoryTag("user/repo"); repo != "user/repo" || tag != "" {
|
|
||||||
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "user/repo", "", repo, tag)
|
|
||||||
}
|
|
||||||
if repo, tag := ParseRepositoryTag("user/repo:tag"); repo != "user/repo" || tag != "tag" {
|
|
||||||
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "user/repo", "tag", repo, tag)
|
|
||||||
}
|
|
||||||
if repo, tag := ParseRepositoryTag("url:5000/repo"); repo != "url:5000/repo" || tag != "" {
|
|
||||||
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "url:5000/repo", "", repo, tag)
|
|
||||||
}
|
|
||||||
if repo, tag := ParseRepositoryTag("url:5000/repo:tag"); repo != "url:5000/repo" || tag != "tag" {
|
|
||||||
t.Errorf("Expected repo: '%s' and tag: '%s', got '%s' and '%s'", "url:5000/repo", "tag", repo, tag)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParsePortMapping(t *testing.T) {
|
|
||||||
data, err := PartParser("ip:public:private", "192.168.1.1:80:8080")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(data) != 3 {
|
|
||||||
t.FailNow()
|
|
||||||
}
|
|
||||||
if data["ip"] != "192.168.1.1" {
|
|
||||||
t.Fail()
|
|
||||||
}
|
|
||||||
if data["public"] != "80" {
|
|
||||||
t.Fail()
|
|
||||||
}
|
|
||||||
if data["private"] != "8080" {
|
|
||||||
t.Fail()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParsePortRange(t *testing.T) {
|
|
||||||
if start, end, err := ParsePortRange("8000-8080"); err != nil || start != 8000 || end != 8080 {
|
|
||||||
t.Fatalf("Error: %s or Expecting {start,end} values {8000,8080} but found {%d,%d}.", err, start, end)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParsePortRangeIncorrectRange(t *testing.T) {
|
|
||||||
if _, _, err := ParsePortRange("9000-8080"); err == nil || !strings.Contains(err.Error(), "Invalid range specified for the Port") {
|
|
||||||
t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParsePortRangeIncorrectEndRange(t *testing.T) {
|
|
||||||
if _, _, err := ParsePortRange("8000-a"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {
|
|
||||||
t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if _, _, err := ParsePortRange("8000-30a"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {
|
|
||||||
t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParsePortRangeIncorrectStartRange(t *testing.T) {
|
|
||||||
if _, _, err := ParsePortRange("a-8000"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {
|
|
||||||
t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if _, _, err := ParsePortRange("30a-8000"); err == nil || !strings.Contains(err.Error(), "invalid syntax") {
|
|
||||||
t.Fatalf("Expecting error 'Invalid range specified for the Port' but received %s.", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,111 +0,0 @@
|
||||||
// +build go1.3
|
|
||||||
|
|
||||||
// Package pools provides a collection of pools which provide various
|
|
||||||
// data types with buffers. These can be used to lower the number of
|
|
||||||
// memory allocations and reuse buffers.
|
|
||||||
//
|
|
||||||
// New pools should be added to this package to allow them to be
|
|
||||||
// shared across packages.
|
|
||||||
//
|
|
||||||
// Utility functions which operate on pools should be added to this
|
|
||||||
// package to allow them to be reused.
|
|
||||||
package pools
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"io"
|
|
||||||
"sync"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/ioutils"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
// Pool which returns bufio.Reader with a 32K buffer
|
|
||||||
BufioReader32KPool *BufioReaderPool
|
|
||||||
// Pool which returns bufio.Writer with a 32K buffer
|
|
||||||
BufioWriter32KPool *BufioWriterPool
|
|
||||||
)
|
|
||||||
|
|
||||||
const buffer32K = 32 * 1024
|
|
||||||
|
|
||||||
type BufioReaderPool struct {
|
|
||||||
pool sync.Pool
|
|
||||||
}
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
BufioReader32KPool = newBufioReaderPoolWithSize(buffer32K)
|
|
||||||
BufioWriter32KPool = newBufioWriterPoolWithSize(buffer32K)
|
|
||||||
}
|
|
||||||
|
|
||||||
// newBufioReaderPoolWithSize is unexported because new pools should be
|
|
||||||
// added here to be shared where required.
|
|
||||||
func newBufioReaderPoolWithSize(size int) *BufioReaderPool {
|
|
||||||
pool := sync.Pool{
|
|
||||||
New: func() interface{} { return bufio.NewReaderSize(nil, size) },
|
|
||||||
}
|
|
||||||
return &BufioReaderPool{pool: pool}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get returns a bufio.Reader which reads from r. The buffer size is that of the pool.
|
|
||||||
func (bufPool *BufioReaderPool) Get(r io.Reader) *bufio.Reader {
|
|
||||||
buf := bufPool.pool.Get().(*bufio.Reader)
|
|
||||||
buf.Reset(r)
|
|
||||||
return buf
|
|
||||||
}
|
|
||||||
|
|
||||||
// Put puts the bufio.Reader back into the pool.
|
|
||||||
func (bufPool *BufioReaderPool) Put(b *bufio.Reader) {
|
|
||||||
b.Reset(nil)
|
|
||||||
bufPool.pool.Put(b)
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewReadCloserWrapper returns a wrapper which puts the bufio.Reader back
|
|
||||||
// into the pool and closes the reader if it's an io.ReadCloser.
|
|
||||||
func (bufPool *BufioReaderPool) NewReadCloserWrapper(buf *bufio.Reader, r io.Reader) io.ReadCloser {
|
|
||||||
return ioutils.NewReadCloserWrapper(r, func() error {
|
|
||||||
if readCloser, ok := r.(io.ReadCloser); ok {
|
|
||||||
readCloser.Close()
|
|
||||||
}
|
|
||||||
bufPool.Put(buf)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
type BufioWriterPool struct {
|
|
||||||
pool sync.Pool
|
|
||||||
}
|
|
||||||
|
|
||||||
// newBufioWriterPoolWithSize is unexported because new pools should be
|
|
||||||
// added here to be shared where required.
|
|
||||||
func newBufioWriterPoolWithSize(size int) *BufioWriterPool {
|
|
||||||
pool := sync.Pool{
|
|
||||||
New: func() interface{} { return bufio.NewWriterSize(nil, size) },
|
|
||||||
}
|
|
||||||
return &BufioWriterPool{pool: pool}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get returns a bufio.Writer which writes to w. The buffer size is that of the pool.
|
|
||||||
func (bufPool *BufioWriterPool) Get(w io.Writer) *bufio.Writer {
|
|
||||||
buf := bufPool.pool.Get().(*bufio.Writer)
|
|
||||||
buf.Reset(w)
|
|
||||||
return buf
|
|
||||||
}
|
|
||||||
|
|
||||||
// Put puts the bufio.Writer back into the pool.
|
|
||||||
func (bufPool *BufioWriterPool) Put(b *bufio.Writer) {
|
|
||||||
b.Reset(nil)
|
|
||||||
bufPool.pool.Put(b)
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewWriteCloserWrapper returns a wrapper which puts the bufio.Writer back
|
|
||||||
// into the pool and closes the writer if it's an io.Writecloser.
|
|
||||||
func (bufPool *BufioWriterPool) NewWriteCloserWrapper(buf *bufio.Writer, w io.Writer) io.WriteCloser {
|
|
||||||
return ioutils.NewWriteCloserWrapper(w, func() error {
|
|
||||||
buf.Flush()
|
|
||||||
if writeCloser, ok := w.(io.WriteCloser); ok {
|
|
||||||
writeCloser.Close()
|
|
||||||
}
|
|
||||||
bufPool.Put(buf)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
@ -1,73 +0,0 @@
|
||||||
// +build !go1.3
|
|
||||||
|
|
||||||
package pools
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"io"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/ioutils"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
BufioReader32KPool *BufioReaderPool
|
|
||||||
BufioWriter32KPool *BufioWriterPool
|
|
||||||
)
|
|
||||||
|
|
||||||
const buffer32K = 32 * 1024
|
|
||||||
|
|
||||||
type BufioReaderPool struct {
|
|
||||||
size int
|
|
||||||
}
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
BufioReader32KPool = newBufioReaderPoolWithSize(buffer32K)
|
|
||||||
BufioWriter32KPool = newBufioWriterPoolWithSize(buffer32K)
|
|
||||||
}
|
|
||||||
|
|
||||||
func newBufioReaderPoolWithSize(size int) *BufioReaderPool {
|
|
||||||
return &BufioReaderPool{size: size}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (bufPool *BufioReaderPool) Get(r io.Reader) *bufio.Reader {
|
|
||||||
return bufio.NewReaderSize(r, bufPool.size)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (bufPool *BufioReaderPool) Put(b *bufio.Reader) {
|
|
||||||
b.Reset(nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (bufPool *BufioReaderPool) NewReadCloserWrapper(buf *bufio.Reader, r io.Reader) io.ReadCloser {
|
|
||||||
return ioutils.NewReadCloserWrapper(r, func() error {
|
|
||||||
if readCloser, ok := r.(io.ReadCloser); ok {
|
|
||||||
return readCloser.Close()
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
type BufioWriterPool struct {
|
|
||||||
size int
|
|
||||||
}
|
|
||||||
|
|
||||||
func newBufioWriterPoolWithSize(size int) *BufioWriterPool {
|
|
||||||
return &BufioWriterPool{size: size}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (bufPool *BufioWriterPool) Get(w io.Writer) *bufio.Writer {
|
|
||||||
return bufio.NewWriterSize(w, bufPool.size)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (bufPool *BufioWriterPool) Put(b *bufio.Writer) {
|
|
||||||
b.Reset(nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (bufPool *BufioWriterPool) NewWriteCloserWrapper(buf *bufio.Writer, w io.Writer) io.WriteCloser {
|
|
||||||
return ioutils.NewWriteCloserWrapper(w, func() error {
|
|
||||||
buf.Flush()
|
|
||||||
if writeCloser, ok := w.(io.WriteCloser); ok {
|
|
||||||
return writeCloser.Close()
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
@ -1,11 +0,0 @@
|
||||||
package promise
|
|
||||||
|
|
||||||
// Go is a basic promise implementation: it wraps calls a function in a goroutine,
|
|
||||||
// and returns a channel which will later return the function's return value.
|
|
||||||
func Go(f func() error) chan error {
|
|
||||||
ch := make(chan error, 1)
|
|
||||||
go func() {
|
|
||||||
ch <- f()
|
|
||||||
}()
|
|
||||||
return ch
|
|
||||||
}
|
|
||||||
|
|
@ -1,2 +0,0 @@
|
||||||
Michael Crosby <michael@crosbymichael.com> (@crosbymichael)
|
|
||||||
Victor Vieux <vieux@docker.com> (@vieux)
|
|
||||||
|
|
@ -1,9 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
ErrNotSupportedPlatform = errors.New("platform and architecture is not supported")
|
|
||||||
)
|
|
||||||
|
|
@ -1,16 +0,0 @@
|
||||||
// +build !windows
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
)
|
|
||||||
|
|
||||||
func Lstat(path string) (*Stat, error) {
|
|
||||||
s := &syscall.Stat_t{}
|
|
||||||
err := syscall.Lstat(path, s)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return fromStatT(s)
|
|
||||||
}
|
|
||||||
|
|
@ -1,27 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"os"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestLstat(t *testing.T) {
|
|
||||||
file, invalid, _, dir := prepareFiles(t)
|
|
||||||
defer os.RemoveAll(dir)
|
|
||||||
|
|
||||||
statFile, err := Lstat(file)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if statFile == nil {
|
|
||||||
t.Fatal("returned empty stat for existing file")
|
|
||||||
}
|
|
||||||
|
|
||||||
statInvalid, err := Lstat(invalid)
|
|
||||||
if err == nil {
|
|
||||||
t.Fatal("did not return error for non-existing file")
|
|
||||||
}
|
|
||||||
if statInvalid != nil {
|
|
||||||
t.Fatal("returned non-nil stat for non-existing file")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,8 +0,0 @@
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
func Lstat(path string) (*Stat, error) {
|
|
||||||
// should not be called on cli code path
|
|
||||||
return nil, ErrNotSupportedPlatform
|
|
||||||
}
|
|
||||||
|
|
@ -1,17 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
// MemInfo contains memory statistics of the host system.
|
|
||||||
type MemInfo struct {
|
|
||||||
// Total usable RAM (i.e. physical RAM minus a few reserved bits and the
|
|
||||||
// kernel binary code).
|
|
||||||
MemTotal int64
|
|
||||||
|
|
||||||
// Amount of free memory.
|
|
||||||
MemFree int64
|
|
||||||
|
|
||||||
// Total amount of swap space available.
|
|
||||||
SwapTotal int64
|
|
||||||
|
|
||||||
// Amount of swap space that is currently unused.
|
|
||||||
SwapFree int64
|
|
||||||
}
|
|
||||||
|
|
@ -1,67 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"errors"
|
|
||||||
"io"
|
|
||||||
"os"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/units"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
ErrMalformed = errors.New("malformed file")
|
|
||||||
)
|
|
||||||
|
|
||||||
// Retrieve memory statistics of the host system and parse them into a MemInfo
|
|
||||||
// type.
|
|
||||||
func ReadMemInfo() (*MemInfo, error) {
|
|
||||||
file, err := os.Open("/proc/meminfo")
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
defer file.Close()
|
|
||||||
return parseMemInfo(file)
|
|
||||||
}
|
|
||||||
|
|
||||||
func parseMemInfo(reader io.Reader) (*MemInfo, error) {
|
|
||||||
meminfo := &MemInfo{}
|
|
||||||
scanner := bufio.NewScanner(reader)
|
|
||||||
for scanner.Scan() {
|
|
||||||
// Expected format: ["MemTotal:", "1234", "kB"]
|
|
||||||
parts := strings.Fields(scanner.Text())
|
|
||||||
|
|
||||||
// Sanity checks: Skip malformed entries.
|
|
||||||
if len(parts) < 3 || parts[2] != "kB" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
// Convert to bytes.
|
|
||||||
size, err := strconv.Atoi(parts[1])
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
bytes := int64(size) * units.KiB
|
|
||||||
|
|
||||||
switch parts[0] {
|
|
||||||
case "MemTotal:":
|
|
||||||
meminfo.MemTotal = bytes
|
|
||||||
case "MemFree:":
|
|
||||||
meminfo.MemFree = bytes
|
|
||||||
case "SwapTotal:":
|
|
||||||
meminfo.SwapTotal = bytes
|
|
||||||
case "SwapFree:":
|
|
||||||
meminfo.SwapFree = bytes
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// Handle errors that may have occurred during the reading of the file.
|
|
||||||
if err := scanner.Err(); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
return meminfo, nil
|
|
||||||
}
|
|
||||||
37
Godeps/_workspace/src/github.com/docker/docker/pkg/system/meminfo_linux_test.go
generated
vendored
37
Godeps/_workspace/src/github.com/docker/docker/pkg/system/meminfo_linux_test.go
generated
vendored
|
|
@ -1,37 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/units"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestMemInfo(t *testing.T) {
|
|
||||||
const input = `
|
|
||||||
MemTotal: 1 kB
|
|
||||||
MemFree: 2 kB
|
|
||||||
SwapTotal: 3 kB
|
|
||||||
SwapFree: 4 kB
|
|
||||||
Malformed1:
|
|
||||||
Malformed2: 1
|
|
||||||
Malformed3: 2 MB
|
|
||||||
Malformed4: X kB
|
|
||||||
`
|
|
||||||
meminfo, err := parseMemInfo(strings.NewReader(input))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if meminfo.MemTotal != 1*units.KiB {
|
|
||||||
t.Fatalf("Unexpected MemTotal: %d", meminfo.MemTotal)
|
|
||||||
}
|
|
||||||
if meminfo.MemFree != 2*units.KiB {
|
|
||||||
t.Fatalf("Unexpected MemFree: %d", meminfo.MemFree)
|
|
||||||
}
|
|
||||||
if meminfo.SwapTotal != 3*units.KiB {
|
|
||||||
t.Fatalf("Unexpected SwapTotal: %d", meminfo.SwapTotal)
|
|
||||||
}
|
|
||||||
if meminfo.SwapFree != 4*units.KiB {
|
|
||||||
t.Fatalf("Unexpected SwapFree: %d", meminfo.SwapFree)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
7
Godeps/_workspace/src/github.com/docker/docker/pkg/system/meminfo_unsupported.go
generated
vendored
7
Godeps/_workspace/src/github.com/docker/docker/pkg/system/meminfo_unsupported.go
generated
vendored
|
|
@ -1,7 +0,0 @@
|
||||||
// +build !linux
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
func ReadMemInfo() (*MemInfo, error) {
|
|
||||||
return nil, ErrNotSupportedPlatform
|
|
||||||
}
|
|
||||||
|
|
@ -1,18 +0,0 @@
|
||||||
// +build !windows
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
)
|
|
||||||
|
|
||||||
func Mknod(path string, mode uint32, dev int) error {
|
|
||||||
return syscall.Mknod(path, mode, dev)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Linux device nodes are a bit weird due to backwards compat with 16 bit device nodes.
|
|
||||||
// They are, from low to high: the lower 8 bits of the minor, then 12 bits of the major,
|
|
||||||
// then the top 12 bits of the minor
|
|
||||||
func Mkdev(major int64, minor int64) uint32 {
|
|
||||||
return uint32(((minor & 0xfff00) << 12) | ((major & 0xfff) << 8) | (minor & 0xff))
|
|
||||||
}
|
|
||||||
|
|
@ -1,12 +0,0 @@
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
func Mknod(path string, mode uint32, dev int) error {
|
|
||||||
// should not be called on cli code path
|
|
||||||
return ErrNotSupportedPlatform
|
|
||||||
}
|
|
||||||
|
|
||||||
func Mkdev(major int64, minor int64) uint32 {
|
|
||||||
panic("Mkdev not implemented on windows, should not be called on cli code")
|
|
||||||
}
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Stat struct {
|
|
||||||
mode uint32
|
|
||||||
uid uint32
|
|
||||||
gid uint32
|
|
||||||
rdev uint64
|
|
||||||
size int64
|
|
||||||
mtim syscall.Timespec
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Stat) Mode() uint32 {
|
|
||||||
return s.mode
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Stat) Uid() uint32 {
|
|
||||||
return s.uid
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Stat) Gid() uint32 {
|
|
||||||
return s.gid
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Stat) Rdev() uint64 {
|
|
||||||
return s.rdev
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Stat) Size() int64 {
|
|
||||||
return s.size
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Stat) Mtim() syscall.Timespec {
|
|
||||||
return s.mtim
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s Stat) GetLastModification() syscall.Timespec {
|
|
||||||
return s.Mtim()
|
|
||||||
}
|
|
||||||
|
|
@ -1,14 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
)
|
|
||||||
|
|
||||||
func fromStatT(s *syscall.Stat_t) (*Stat, error) {
|
|
||||||
return &Stat{size: s.Size,
|
|
||||||
mode: s.Mode,
|
|
||||||
uid: s.Uid,
|
|
||||||
gid: s.Gid,
|
|
||||||
rdev: s.Rdev,
|
|
||||||
mtim: s.Mtim}, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,36 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"os"
|
|
||||||
"syscall"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestFromStatT(t *testing.T) {
|
|
||||||
file, _, _, dir := prepareFiles(t)
|
|
||||||
defer os.RemoveAll(dir)
|
|
||||||
|
|
||||||
stat := &syscall.Stat_t{}
|
|
||||||
err := syscall.Lstat(file, stat)
|
|
||||||
|
|
||||||
s, err := fromStatT(stat)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if stat.Mode != s.Mode() {
|
|
||||||
t.Fatal("got invalid mode")
|
|
||||||
}
|
|
||||||
if stat.Uid != s.Uid() {
|
|
||||||
t.Fatal("got invalid uid")
|
|
||||||
}
|
|
||||||
if stat.Gid != s.Gid() {
|
|
||||||
t.Fatal("got invalid gid")
|
|
||||||
}
|
|
||||||
if stat.Rdev != s.Rdev() {
|
|
||||||
t.Fatal("got invalid rdev")
|
|
||||||
}
|
|
||||||
if stat.Mtim != s.Mtim() {
|
|
||||||
t.Fatal("got invalid mtim")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,16 +0,0 @@
|
||||||
// +build !linux,!windows
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
)
|
|
||||||
|
|
||||||
func fromStatT(s *syscall.Stat_t) (*Stat, error) {
|
|
||||||
return &Stat{size: s.Size,
|
|
||||||
mode: uint32(s.Mode),
|
|
||||||
uid: s.Uid,
|
|
||||||
gid: s.Gid,
|
|
||||||
rdev: uint64(s.Rdev),
|
|
||||||
mtim: s.Mtimespec}, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,12 +0,0 @@
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"syscall"
|
|
||||||
)
|
|
||||||
|
|
||||||
func fromStatT(s *syscall.Win32FileAttributeData) (*Stat, error) {
|
|
||||||
return nil, errors.New("fromStatT should not be called on windows path")
|
|
||||||
}
|
|
||||||
|
|
@ -1,11 +0,0 @@
|
||||||
// +build !windows
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
)
|
|
||||||
|
|
||||||
func Umask(newmask int) (oldmask int, err error) {
|
|
||||||
return syscall.Umask(newmask), nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,8 +0,0 @@
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package system
|
|
||||||
|
|
||||||
func Umask(newmask int) (oldmask int, err error) {
|
|
||||||
// should not be called on cli code path
|
|
||||||
return 0, ErrNotSupportedPlatform
|
|
||||||
}
|
|
||||||
|
|
@ -1,11 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import "syscall"
|
|
||||||
|
|
||||||
func LUtimesNano(path string, ts []syscall.Timespec) error {
|
|
||||||
return ErrNotSupportedPlatform
|
|
||||||
}
|
|
||||||
|
|
||||||
func UtimesNano(path string, ts []syscall.Timespec) error {
|
|
||||||
return syscall.UtimesNano(path, ts)
|
|
||||||
}
|
|
||||||
|
|
@ -1,24 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
"unsafe"
|
|
||||||
)
|
|
||||||
|
|
||||||
func LUtimesNano(path string, ts []syscall.Timespec) error {
|
|
||||||
var _path *byte
|
|
||||||
_path, err := syscall.BytePtrFromString(path)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if _, _, err := syscall.Syscall(syscall.SYS_LUTIMES, uintptr(unsafe.Pointer(_path)), uintptr(unsafe.Pointer(&ts[0])), 0); err != 0 && err != syscall.ENOSYS {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func UtimesNano(path string, ts []syscall.Timespec) error {
|
|
||||||
return syscall.UtimesNano(path, ts)
|
|
||||||
}
|
|
||||||
|
|
@ -1,28 +0,0 @@
|
||||||
package system
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
"unsafe"
|
|
||||||
)
|
|
||||||
|
|
||||||
func LUtimesNano(path string, ts []syscall.Timespec) error {
|
|
||||||
// These are not currently available in syscall
|
|
||||||
AT_FDCWD := -100
|
|
||||||
AT_SYMLINK_NOFOLLOW := 0x100
|
|
||||||
|
|
||||||
var _path *byte
|
|
||||||
_path, err := syscall.BytePtrFromString(path)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if _, _, err := syscall.Syscall6(syscall.SYS_UTIMENSAT, uintptr(AT_FDCWD), uintptr(unsafe.Pointer(_path)), uintptr(unsafe.Pointer(&ts[0])), uintptr(AT_SYMLINK_NOFOLLOW), 0, 0); err != 0 && err != syscall.ENOSYS {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func UtimesNano(path string, ts []syscall.Timespec) error {
|
|
||||||
return syscall.UtimesNano(path, ts)
|
|
||||||
}
|
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue