mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
Merge branch 'master' of github.com:dotcloud/docker
This commit is contained in:
Andrea Luzzardi
commit
4fc390ee39
3 changed files with 414 additions and 257 deletions
206
docker/docker.go
206
docker/docker.go
|
|
@ -2,44 +2,196 @@ package main
|
|||
|
||||
import (
|
||||
"io"
|
||||
"encoding/json"
|
||||
"log"
|
||||
"os"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"net"
|
||||
"fmt"
|
||||
"syscall"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
|
||||
// Use this key to encode an RPC call into an URL,
|
||||
// eg. domain.tld/path/to/method?q=get_user&q=gordon
|
||||
const ARG_URL_KEY = "q"
|
||||
type Termios struct {
|
||||
Iflag uintptr
|
||||
Oflag uintptr
|
||||
Cflag uintptr
|
||||
Lflag uintptr
|
||||
Cc [20]byte
|
||||
Ispeed uintptr
|
||||
Ospeed uintptr
|
||||
}
|
||||
|
||||
func CallToURL(host string, cmd string, args []string) *url.URL {
|
||||
qValues := make(url.Values)
|
||||
for _, v := range args {
|
||||
qValues.Add(ARG_URL_KEY, v)
|
||||
}
|
||||
return &url.URL{
|
||||
Scheme: "http",
|
||||
Host: host,
|
||||
Path: "/" + cmd,
|
||||
RawQuery: qValues.Encode(),
|
||||
}
|
||||
const (
|
||||
getTermios = syscall.TIOCGETA
|
||||
setTermios = syscall.TIOCSETA
|
||||
)
|
||||
|
||||
const (
|
||||
// Input flags
|
||||
inpck = 0x010
|
||||
istrip = 0x020
|
||||
icrnl = 0x100
|
||||
ixon = 0x200
|
||||
|
||||
// Output flags
|
||||
opost = 0x1
|
||||
|
||||
// Control flags
|
||||
cs8 = 0x300
|
||||
|
||||
// Local flags
|
||||
icanon = 0x100
|
||||
iexten = 0x400
|
||||
)
|
||||
|
||||
const (
|
||||
HUPCL = 0x4000
|
||||
ICANON = 0x100
|
||||
ICRNL = 0x100
|
||||
IEXTEN = 0x400
|
||||
BRKINT = 0x2
|
||||
CFLUSH = 0xf
|
||||
CLOCAL = 0x8000
|
||||
CREAD = 0x800
|
||||
CS5 = 0x0
|
||||
CS6 = 0x100
|
||||
CS7 = 0x200
|
||||
CS8 = 0x300
|
||||
CSIZE = 0x300
|
||||
CSTART = 0x11
|
||||
CSTATUS = 0x14
|
||||
CSTOP = 0x13
|
||||
CSTOPB = 0x400
|
||||
CSUSP = 0x1a
|
||||
IGNBRK = 0x1
|
||||
IGNCR = 0x80
|
||||
IGNPAR = 0x4
|
||||
IMAXBEL = 0x2000
|
||||
INLCR = 0x40
|
||||
INPCK = 0x10
|
||||
ISIG = 0x80
|
||||
ISTRIP = 0x20
|
||||
IUTF8 = 0x4000
|
||||
IXANY = 0x800
|
||||
IXOFF = 0x400
|
||||
IXON = 0x200
|
||||
NOFLSH = 0x80000000
|
||||
OCRNL = 0x10
|
||||
OFDEL = 0x20000
|
||||
OFILL = 0x80
|
||||
ONLCR = 0x2
|
||||
ONLRET = 0x40
|
||||
ONOCR = 0x20
|
||||
ONOEOT = 0x8
|
||||
OPOST = 0x1
|
||||
RENB = 0x1000
|
||||
PARMRK = 0x8
|
||||
PARODD = 0x2000
|
||||
|
||||
TOSTOP = 0x400000
|
||||
VDISCARD = 0xf
|
||||
VDSUSP = 0xb
|
||||
VEOF = 0x0
|
||||
VEOL = 0x1
|
||||
VEOL2 = 0x2
|
||||
VERASE = 0x3
|
||||
VINTR = 0x8
|
||||
VKILL = 0x5
|
||||
VLNEXT = 0xe
|
||||
VMIN = 0x10
|
||||
VQUIT = 0x9
|
||||
VREPRINT = 0x6
|
||||
VSTART = 0xc
|
||||
VSTATUS = 0x12
|
||||
VSTOP = 0xd
|
||||
VSUSP = 0xa
|
||||
VT0 = 0x0
|
||||
VT1 = 0x10000
|
||||
VTDLY = 0x10000
|
||||
VTIME = 0x11
|
||||
ECHO = 0x00000008
|
||||
|
||||
PENDIN = 0x20000000
|
||||
)
|
||||
|
||||
type State struct {
|
||||
termios Termios
|
||||
}
|
||||
|
||||
// IsTerminal returns true if the given file descriptor is a terminal.
|
||||
func IsTerminal(fd int) bool {
|
||||
var termios Termios
|
||||
_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
|
||||
return err == 0
|
||||
}
|
||||
|
||||
// MakeRaw put the terminal connected to the given file descriptor into raw
|
||||
// mode and returns the previous state of the terminal so that it can be
|
||||
// restored.
|
||||
func MakeRaw(fd int) (*State, error) {
|
||||
var oldState State
|
||||
if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&oldState.termios)), 0, 0, 0); err != 0 {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
newState := oldState.termios
|
||||
newState.Iflag &^= istrip | INLCR | ICRNL | IGNCR | IXON | IXOFF
|
||||
newState.Lflag &^= ECHO | ICANON | ISIG
|
||||
if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &oldState, nil
|
||||
}
|
||||
|
||||
|
||||
// Restore restores the terminal connected to the given file descriptor to a
|
||||
// previous state.
|
||||
func Restore(fd int, state *State) error {
|
||||
_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&state.termios)), 0, 0, 0)
|
||||
return err
|
||||
}
|
||||
|
||||
var oldState *State
|
||||
|
||||
func Fatal(err error) {
|
||||
if oldState != nil {
|
||||
Restore(0, oldState)
|
||||
}
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
|
||||
func main() {
|
||||
var cmd string
|
||||
var args []string
|
||||
if len(os.Args) >= 2 {
|
||||
cmd = os.Args[1]
|
||||
var err error
|
||||
if IsTerminal(0) {
|
||||
oldState, err = MakeRaw(0)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer Restore(0, oldState)
|
||||
}
|
||||
if len(os.Args) >= 3 {
|
||||
args = os.Args[2:]
|
||||
}
|
||||
u := CallToURL(os.Getenv("DOCKER"), cmd, args)
|
||||
resp, err := http.Get(u.String())
|
||||
cmd, err := json.Marshal(os.Args[1:])
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
Fatal(err)
|
||||
}
|
||||
io.Copy(os.Stdout, resp.Body)
|
||||
conn, err := net.Dial("tcp", os.Getenv("DOCKER"))
|
||||
if err != nil {
|
||||
Fatal(err)
|
||||
}
|
||||
if _, err := fmt.Fprintln(conn, string(cmd)); err != nil {
|
||||
Fatal(err)
|
||||
}
|
||||
go func() {
|
||||
if _, err := io.Copy(os.Stdout, conn); err != nil {
|
||||
Fatal(err)
|
||||
}
|
||||
Restore(0, oldState)
|
||||
os.Exit(0)
|
||||
}()
|
||||
if _, err := io.Copy(conn, os.Stdin); err != nil {
|
||||
Fatal(err)
|
||||
}
|
||||
Restore(0, oldState)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,12 +1,14 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"errors"
|
||||
"log"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net"
|
||||
"net/url"
|
||||
"net/http"
|
||||
"os/exec"
|
||||
"flag"
|
||||
"reflect"
|
||||
|
|
@ -22,6 +24,7 @@ import (
|
|||
"sort"
|
||||
"os"
|
||||
"archive/tar"
|
||||
"encoding/json"
|
||||
)
|
||||
|
||||
func (docker *Docker) CmdHelp(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
|
|
@ -29,16 +32,15 @@ func (docker *Docker) CmdHelp(stdin io.ReadCloser, stdout io.Writer, args ...str
|
|||
fmt.Fprintf(stdout, "Usage: docker COMMAND [arg...]\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n")
|
||||
for _, cmd := range [][]interface{}{
|
||||
{"run", "Run a command in a container"},
|
||||
{"clone", "Duplicate a container"},
|
||||
{"list", "Display a list of containers"},
|
||||
{"layers", "Display a list of layers"},
|
||||
{"get", "Download a layer from a remote location"},
|
||||
{"rm", "Remove layers"},
|
||||
{"get", "Download a tarball and create a container from it"},
|
||||
{"put", "Upload a tarball and create a container from it"},
|
||||
{"rm", "Remove containers"},
|
||||
{"wait", "Wait for the state of a container to change"},
|
||||
{"stop", "Stop a running container"},
|
||||
{"logs", "Fetch the logs of a container"},
|
||||
{"diff", "Inspect changes on a container's filesystem"},
|
||||
{"snapshot", "Create a new layer from a container's filesystem"},
|
||||
{"fork", "Duplicate a container"},
|
||||
{"attach", "Attach to the standard inputs and outputs of a running container"},
|
||||
{"info", "Display system-wide information"},
|
||||
{"web", "Generate a web UI"},
|
||||
|
|
@ -55,10 +57,10 @@ func (docker *Docker) CmdHelp(stdin io.ReadCloser, stdout io.Writer, args ...str
|
|||
return nil
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdLayers(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout, "layers", "[OPTIONS] [NAME]", "Show available filesystem layers")
|
||||
quiet := flags.Bool("q", false, "Quiet mode")
|
||||
limit := flags.Int("l", 0, "Only show the N most recent versions of each layer")
|
||||
func (docker *Docker) CmdList(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout, "list", "[OPTIONS] [NAME]", "List containers")
|
||||
limit := flags.Int("l", 0, "Only show the N most recent versions of each name")
|
||||
quiet := flags.Bool("q", false, "only show numeric IDs")
|
||||
flags.Parse(args)
|
||||
if flags.NArg() > 1 {
|
||||
flags.Usage()
|
||||
|
|
@ -69,26 +71,42 @@ func (docker *Docker) CmdLayers(stdin io.ReadCloser, stdout io.Writer, args ...s
|
|||
nameFilter = flags.Arg(0)
|
||||
}
|
||||
var names []string
|
||||
for name := range docker.layersByName {
|
||||
for name := range docker.containersByName {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Strings(names)
|
||||
w := tabwriter.NewWriter(stdout, 20, 1, 3, ' ', 0)
|
||||
if (!*quiet) {
|
||||
fmt.Fprintf(w, "ID\tNAME\tSIZE\tADDED\tSOURCE\n")
|
||||
fmt.Fprintf(w, "NAME\tID\tCREATED\tSOURCE\tSIZE\tCHANGES\tRUNNING\tCOMMAND\n")
|
||||
}
|
||||
for _, name := range names {
|
||||
if nameFilter != "" && nameFilter != name {
|
||||
continue
|
||||
}
|
||||
for idx, layer := range *docker.layersByName[name] {
|
||||
for idx, container := range *docker.containersByName[name] {
|
||||
if *limit > 0 && idx >= *limit {
|
||||
break
|
||||
}
|
||||
if !*quiet {
|
||||
fmt.Fprintf(w, "%s\t%s\t%.1fM\t%s ago\t%s\n", layer.Id, layer.Name, float32(layer.Size) / 1024 / 1024, humanDuration(time.Now().Sub(layer.Added)), layer.Source)
|
||||
for idx, field := range []string{
|
||||
/* NAME */ container.Name,
|
||||
/* ID */ container.Id,
|
||||
/* CREATED */ humanDuration(time.Now().Sub(container.Created)) + " ago",
|
||||
/* SOURCE */ container.Source,
|
||||
/* SIZE */ fmt.Sprintf("%.1fM", float32(container.Size) / 1024 / 1024),
|
||||
/* CHANGES */ fmt.Sprintf("%.1fM", float32(container.BytesChanged) / 1024 / 1024),
|
||||
/* RUNNING */ fmt.Sprintf("%v", container.Running),
|
||||
/* COMMAND */ container.CmdString(),
|
||||
} {
|
||||
if idx == 0 {
|
||||
w.Write([]byte(field))
|
||||
} else {
|
||||
w.Write([]byte("\t" + field))
|
||||
}
|
||||
}
|
||||
w.Write([]byte{'\n'})
|
||||
} else {
|
||||
stdout.Write([]byte(layer.Id + "\n"))
|
||||
stdout.Write([]byte(container.Id + "\n"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -98,37 +116,26 @@ func (docker *Docker) CmdLayers(stdin io.ReadCloser, stdout io.Writer, args ...s
|
|||
return nil
|
||||
}
|
||||
|
||||
func (docker *Docker) findLayer(name string) (*Layer, bool) {
|
||||
// 1: look for layer by ID
|
||||
if layer, exists := docker.layers[name]; exists {
|
||||
return layer, true
|
||||
func (docker *Docker) findContainer(name string) (*Container, bool) {
|
||||
// 1: look for container by ID
|
||||
if container, exists := docker.containers[name]; exists {
|
||||
return container, true
|
||||
}
|
||||
// 2: look for a layer by name (and pick the most recent)
|
||||
if layers, exists := docker.layersByName[name]; exists {
|
||||
return (*layers)[0], true
|
||||
// 2: look for a container by name (and pick the most recent)
|
||||
if containers, exists := docker.containersByName[name]; exists {
|
||||
return (*containers)[0], true
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
|
||||
func (docker *Docker) usingLayer(layer *Layer) []*Container {
|
||||
var containers []*Container
|
||||
for _, container := range docker.containers {
|
||||
for _, l := range container.Layers {
|
||||
if l.Id == layer.Id {
|
||||
containers = append(containers, &container)
|
||||
}
|
||||
}
|
||||
}
|
||||
return containers
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdRm(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout, "rm", "[OPTIONS LAYER", "Remove a layer")
|
||||
flags := Subcmd(stdout, "rm", "[OPTIONS] CONTAINER", "Remove a container")
|
||||
if err := flags.Parse(args); err != nil {
|
||||
return nil
|
||||
}
|
||||
for _, name := range flags.Args() {
|
||||
if _, err := docker.rmLayer(name); err != nil {
|
||||
if _, err := docker.rm(name); err != nil {
|
||||
fmt.Fprintln(stdout, "Error: " + err.Error())
|
||||
}
|
||||
}
|
||||
|
|
@ -140,7 +147,7 @@ func (docker *Docker) CmdGet(stdin io.ReadCloser, stdout io.Writer, args ...stri
|
|||
return errors.New("Not enough arguments")
|
||||
}
|
||||
time.Sleep(2 * time.Second)
|
||||
layer := docker.addLayer(args[0], "download", 0)
|
||||
layer := docker.addContainer(args[0], "download", 0)
|
||||
fmt.Fprintln(stdout, layer.Id)
|
||||
return nil
|
||||
}
|
||||
|
|
@ -150,46 +157,48 @@ func (docker *Docker) CmdPut(stdin io.ReadCloser, stdout io.Writer, args ...stri
|
|||
return errors.New("Not enough arguments")
|
||||
}
|
||||
time.Sleep(1 * time.Second)
|
||||
layer := docker.addLayer(args[0], "upload", 0)
|
||||
layer := docker.addContainer(args[0], "upload", 0)
|
||||
fmt.Fprintln(stdout, layer.Id)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdSnapshot(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
func (docker *Docker) CmdFork(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout,
|
||||
"snapshot", "[OPTIONS] CONTAINER IMAGE",
|
||||
"Crete a new layer from a container's filesystem")
|
||||
"fork", "[OPTIONS] CONTAINER [DEST]",
|
||||
"Duplicate a container")
|
||||
// FIXME "-r" to reset changes in the new container
|
||||
if err := flags.Parse(args); err != nil {
|
||||
return nil
|
||||
}
|
||||
if flags.NArg() != 2 {
|
||||
srcName, dstName := flags.Arg(0), flags.Arg(1)
|
||||
if srcName == "" {
|
||||
flags.Usage()
|
||||
return nil
|
||||
}
|
||||
containerName, layerName := flags.Arg(0), flags.Arg(1)
|
||||
if container, exists := docker.containers[containerName]; exists {
|
||||
layer := docker.addLayer(layerName, "snapshot:" + container.Id, container.BytesChanged)
|
||||
fmt.Fprintln(stdout, layer.Id)
|
||||
if dstName == "" {
|
||||
dstName = srcName
|
||||
}
|
||||
if src, exists := docker.findContainer(srcName); exists {
|
||||
dst := docker.addContainer(dstName, "snapshot:" + src.Id, src.Size)
|
||||
fmt.Fprintln(stdout, dst.Id)
|
||||
return nil
|
||||
}
|
||||
return errors.New("No such container: " + flags.Arg(0))
|
||||
return errors.New("No such container: " + srcName)
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdTar(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout,
|
||||
"tar", "CONTAINER|LAYER [OPTIONS]",
|
||||
"Stream the contents of a container or a layer as a tar archive")
|
||||
"tar", "CONTAINER",
|
||||
"Stream the contents of a container as a tar archive")
|
||||
if err := flags.Parse(args); err != nil {
|
||||
return nil
|
||||
}
|
||||
name := flags.Arg(0)
|
||||
if _, exists := docker.containers[name]; exists {
|
||||
if _, exists := docker.findContainer(name); exists {
|
||||
// Stream the entire contents of the container (basically a volatile snapshot)
|
||||
return WriteFakeTar(stdout)
|
||||
} else if _, exists := docker.findLayer(name); exists {
|
||||
return WriteFakeTar(stdout)
|
||||
}
|
||||
return errors.New("No such layer or container: " + name)
|
||||
return errors.New("No such container: " + name)
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdDiff(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
|
|
@ -205,7 +214,7 @@ func (docker *Docker) CmdDiff(stdin io.ReadCloser, stdout io.Writer, args ...str
|
|||
if flags.NArg() < 1 {
|
||||
return errors.New("Not enough arguments")
|
||||
}
|
||||
if container, exists := docker.containers[flags.Arg(0)]; !exists {
|
||||
if container, exists := docker.findContainer(flags.Arg(0)); !exists {
|
||||
return errors.New("No such container")
|
||||
} else if *fl_bytes {
|
||||
fmt.Fprintf(stdout, "%d\n", container.BytesChanged)
|
||||
|
|
@ -248,76 +257,77 @@ index 2dae694..e43caca 100644
|
|||
|
||||
// ByDate wraps an array of layers so they can be sorted by date (most recent first)
|
||||
|
||||
type ByDate []*Layer
|
||||
type ByDate []*Container
|
||||
|
||||
func (l *ByDate) Len() int {
|
||||
return len(*l)
|
||||
func (c *ByDate) Len() int {
|
||||
return len(*c)
|
||||
}
|
||||
|
||||
func (l *ByDate) Less(i, j int) bool {
|
||||
layers := *l
|
||||
return layers[j].Added.Before(layers[i].Added)
|
||||
func (c *ByDate) Less(i, j int) bool {
|
||||
containers := *c
|
||||
return containers[j].Created.Before(containers[i].Created)
|
||||
}
|
||||
|
||||
func (l *ByDate) Swap(i, j int) {
|
||||
layers := *l
|
||||
tmp := layers[i]
|
||||
layers[i] = layers[j]
|
||||
layers[j] = tmp
|
||||
func (c *ByDate) Swap(i, j int) {
|
||||
containers := *c
|
||||
tmp := containers[i]
|
||||
containers[i] = containers[j]
|
||||
containers[j] = tmp
|
||||
}
|
||||
|
||||
func (l *ByDate) Add(layer *Layer) {
|
||||
*l = append(*l, layer)
|
||||
sort.Sort(l)
|
||||
func (c *ByDate) Add(container *Container) {
|
||||
*c = append(*c, container)
|
||||
sort.Sort(c)
|
||||
}
|
||||
|
||||
func (l *ByDate) Del(id string) {
|
||||
for idx, layer := range *l {
|
||||
if layer.Id == id {
|
||||
*l = append((*l)[:idx], (*l)[idx + 1:]...)
|
||||
func (c *ByDate) Del(id string) {
|
||||
for idx, container := range *c {
|
||||
if container.Id == id {
|
||||
*c = append((*c)[:idx], (*c)[idx + 1:]...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func (docker *Docker) addLayer(name string, source string, size uint) *Layer {
|
||||
func (docker *Docker) addContainer(name string, source string, size uint) *Container {
|
||||
// Generate a fake random size
|
||||
if size == 0 {
|
||||
size = uint(rand.Int31n(142 * 1024 * 1024))
|
||||
}
|
||||
layer := &Layer{Id: randomId(), Name: name, Source: source, Added: time.Now(), Size: size}
|
||||
docker.layers[layer.Id] = layer
|
||||
if _, exists := docker.layersByName[layer.Name]; !exists {
|
||||
docker.layersByName[layer.Name] = new(ByDate)
|
||||
c := &Container{
|
||||
Id: randomId(),
|
||||
Name: name,
|
||||
Created: time.Now(),
|
||||
Source: source,
|
||||
Size: size,
|
||||
stdinLog: new(bytes.Buffer),
|
||||
stdoutLog: new(bytes.Buffer),
|
||||
}
|
||||
docker.layersByName[layer.Name].Add(layer)
|
||||
return layer
|
||||
docker.containers[c.Id] = c
|
||||
if _, exists := docker.containersByName[c.Name]; !exists {
|
||||
docker.containersByName[c.Name] = new(ByDate)
|
||||
}
|
||||
docker.containersByName[c.Name].Add(c)
|
||||
return c
|
||||
|
||||
}
|
||||
|
||||
func (docker *Docker) rmLayer(id string) (*Layer, error) {
|
||||
if layer, exists := docker.layers[id]; exists {
|
||||
if containers := docker.usingLayer(layer); len(containers) > 0 {
|
||||
return nil, errors.New(fmt.Sprintf("Layer is in use: %s", id))
|
||||
|
||||
func (docker *Docker) rm(id string) (*Container, error) {
|
||||
if container, exists := docker.containers[id]; exists {
|
||||
if container.Running {
|
||||
return nil, errors.New("Container is running: " + id)
|
||||
} else {
|
||||
// Remove from name lookup
|
||||
docker.layersByName[layer.Name].Del(layer.Id)
|
||||
docker.containersByName[container.Name].Del(container.Id)
|
||||
// Remove from id lookup
|
||||
delete(docker.layers, layer.Id)
|
||||
return layer, nil
|
||||
delete(docker.containers, container.Id)
|
||||
return container, nil
|
||||
}
|
||||
}
|
||||
return nil, errors.New(fmt.Sprintf("No such layer: %s", id))
|
||||
return nil, errors.New(fmt.Sprintf("No such container: %s", id))
|
||||
}
|
||||
|
||||
type ArgList []string
|
||||
|
||||
func (l *ArgList) Set(value string) error {
|
||||
*l = append(*l, value)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (l *ArgList) String() string {
|
||||
return strings.Join(*l, ",")
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout, "logs", "[OPTIONS] CONTAINER", "Fetch the logs of a container")
|
||||
|
|
@ -328,80 +338,40 @@ func (docker *Docker) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...str
|
|||
flags.Usage()
|
||||
return nil
|
||||
}
|
||||
if container, exists := docker.containers[flags.Arg(0)]; exists {
|
||||
name := flags.Arg(0)
|
||||
if container, exists := docker.findContainer(name); exists {
|
||||
if _, err := io.Copy(stdout, container.StdoutLog()); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
return errors.New("No such container: " + flags.Arg(0))
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdRun(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout, "run", "-l LAYER [-l LAYER...] COMMAND {ARG...]", "Run a command in a container")
|
||||
fl_layers := new(ArgList)
|
||||
flags.Var(fl_layers, "l", "Add a layer to the filesystem. Multiple layers are added in the order they are defined")
|
||||
flags := Subcmd(stdout, "run", "[OPTIONS] CONTAINER COMMAND [ARG...]", "Run a command in a container")
|
||||
fl_attach := flags.Bool("a", false, "Attach stdin and stdout")
|
||||
if err := flags.Parse(args); err != nil {
|
||||
return nil
|
||||
}
|
||||
if len(*fl_layers) < 1 {
|
||||
return errors.New("Please specify at least one layer")
|
||||
}
|
||||
if flags.NArg() < 1 {
|
||||
return errors.New("No command specified")
|
||||
}
|
||||
cmd := flags.Arg(0)
|
||||
var cmd_args []string
|
||||
if flags.NArg() > 1 {
|
||||
cmd_args = flags.Args()[1:]
|
||||
}
|
||||
container := Container{
|
||||
Id: randomId(),
|
||||
Cmd: cmd,
|
||||
Args: cmd_args,
|
||||
Created: time.Now(),
|
||||
FilesChanged: uint(rand.Int31n(42)),
|
||||
BytesChanged: uint(rand.Int31n(24 * 1024 * 1024)),
|
||||
stdinLog: new(bytes.Buffer),
|
||||
stdoutLog: new(bytes.Buffer),
|
||||
}
|
||||
for _, name := range *fl_layers {
|
||||
if layer, exists := docker.findLayer(name); exists {
|
||||
container.Layers = append(container.Layers, layer)
|
||||
} else if srcContainer, exists := docker.containers[name]; exists {
|
||||
for _, layer := range srcContainer.Layers {
|
||||
container.Layers = append(container.Layers, layer)
|
||||
}
|
||||
} else {
|
||||
return errors.New("No such layer or container: " + name)
|
||||
}
|
||||
}
|
||||
docker.containers[container.Id] = container
|
||||
if *fl_attach {
|
||||
return container.Run(stdin, stdout)
|
||||
} else {
|
||||
go container.Run(ioutil.NopCloser(new(bytes.Buffer)), ioutil.Discard)
|
||||
fmt.Fprintln(stdout, container.Id)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdClone(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout, "Clone", "[OPTIONS] CONTAINER_ID", "Duplicate a container")
|
||||
reset := flags.Bool("r", true, "Reset: don't keep filesystem changes from the source container")
|
||||
flags.Parse(args)
|
||||
if !*reset {
|
||||
return errors.New("Only reset mode is available for now. Please use -r")
|
||||
}
|
||||
if flags.NArg() != 1 {
|
||||
if flags.NArg() < 2 {
|
||||
flags.Usage()
|
||||
return nil
|
||||
}
|
||||
container, exists := docker.containers[flags.Arg(0)];
|
||||
if !exists {
|
||||
return errors.New("No such container: " + flags.Arg(0))
|
||||
name, cmd := flags.Arg(0), flags.Args()[1:]
|
||||
if container, exists := docker.findContainer(name); exists {
|
||||
if container.Running {
|
||||
return errors.New("Already running: " + name)
|
||||
}
|
||||
if *fl_attach {
|
||||
return container.Run(cmd[0], cmd[1:], stdin, stdout)
|
||||
} else {
|
||||
go container.Run(cmd[0], cmd[1:], ioutil.NopCloser(new(bytes.Buffer)), ioutil.Discard)
|
||||
fmt.Fprintln(stdout, container.Id)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return docker.CmdRun(stdin, stdout, append([]string{"-l", container.Id, "--", container.Cmd}, container.Args...)...)
|
||||
return errors.New("No such container: " + name)
|
||||
}
|
||||
|
||||
func startCommand(cmd *exec.Cmd, interactive bool) (io.WriteCloser, io.ReadCloser, error) {
|
||||
|
|
@ -426,56 +396,64 @@ func startCommand(cmd *exec.Cmd, interactive bool) (io.WriteCloser, io.ReadClose
|
|||
return stdin, stdout, nil
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdList(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := Subcmd(stdout, "list", "[OPTIONS]", "Show all containers")
|
||||
numeric := flags.Bool("n", false, "Display absolute layer IDs instead of names")
|
||||
flags.Parse(args)
|
||||
var longestCol int
|
||||
for _, container := range docker.containers {
|
||||
if l := len(container.CmdString()); l > longestCol {
|
||||
longestCol = l
|
||||
}
|
||||
func (docker *Docker) ListenAndServeTCP(addr string) error {
|
||||
listener, err := net.Listen("tcp", addr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if longestCol > 50 {
|
||||
longestCol = 50
|
||||
} else if longestCol < 5 {
|
||||
longestCol = 8
|
||||
}
|
||||
tpl := "%-16s %-*.*s %-6s %-25s %10s %-s\n"
|
||||
fmt.Fprintf(stdout, tpl, "ID", longestCol, longestCol, "CMD", "RUNNING", "CREATED", "CHANGES", "LAYERS")
|
||||
for _, container := range docker.containers {
|
||||
var layers []string
|
||||
for _, layer := range container.Layers {
|
||||
if *numeric {
|
||||
layers = append(layers, layer.Id)
|
||||
} else {
|
||||
layers = append(layers, layer.Name)
|
||||
}
|
||||
defer listener.Close()
|
||||
for {
|
||||
if conn, err := listener.Accept(); err != nil {
|
||||
return err
|
||||
} else {
|
||||
go func() {
|
||||
if err := docker.serve(conn); err != nil {
|
||||
log.Printf("Error: " + err.Error() + "\n")
|
||||
fmt.Fprintf(conn, "Error: " + err.Error() + "\n")
|
||||
}
|
||||
conn.Close()
|
||||
}()
|
||||
}
|
||||
fmt.Fprintf(stdout, tpl,
|
||||
/* ID */ container.Id,
|
||||
/* CMD */ longestCol, longestCol, container.CmdString(),
|
||||
/* RUNNING */ fmt.Sprintf("%v", container.Running),
|
||||
/* CREATED */ humanDuration(time.Now().Sub(container.Created)) + " ago",
|
||||
/* CHANGES */ fmt.Sprintf("%.1fM", float32(container.BytesChanged) / 1024 / 1024),
|
||||
/* LAYERS */ strings.Join(layers, ","))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (docker *Docker) ListenAndServeHTTP(addr string) error {
|
||||
return http.ListenAndServe(addr, docker)
|
||||
}
|
||||
|
||||
|
||||
func main() {
|
||||
rand.Seed(time.Now().UTC().UnixNano())
|
||||
flag.Parse()
|
||||
if err := http.ListenAndServe(":4242", New()); err != nil {
|
||||
docker := New()
|
||||
go func() {
|
||||
if err := docker.ListenAndServeHTTP(":8080"); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}()
|
||||
if err := docker.ListenAndServeTCP(":4242"); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func (docker *Docker) serve(conn net.Conn) error {
|
||||
r := bufio.NewReader(conn)
|
||||
var args []string
|
||||
if line, err := r.ReadString('\n'); err != nil {
|
||||
return err
|
||||
} else if err := json.Unmarshal([]byte(line), &args); err != nil {
|
||||
return err
|
||||
} else {
|
||||
return docker.Call(ioutil.NopCloser(r), conn, args...)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func New() *Docker {
|
||||
return &Docker{
|
||||
layers: make(map[string]*Layer),
|
||||
layersByName: make(map[string]*ByDate),
|
||||
containers: make(map[string]Container),
|
||||
containersByName: make(map[string]*ByDate),
|
||||
containers: make(map[string]*Container),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -492,30 +470,50 @@ func (w *AutoFlush) Write(data []byte) (int, error) {
|
|||
}
|
||||
|
||||
func (docker *Docker) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
stdout := &AutoFlush{w}
|
||||
stdin := r.Body
|
||||
cmd, args := URLToCall(r.URL)
|
||||
if err := docker.Call(r.Body, &AutoFlush{w}, append([]string{cmd}, args...)...); err != nil {
|
||||
fmt.Fprintf(w, "Error: " + err.Error() + "\n")
|
||||
}
|
||||
}
|
||||
|
||||
func (docker *Docker) Call(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
flags := flag.NewFlagSet("docker", flag.ContinueOnError)
|
||||
flags.SetOutput(stdout)
|
||||
flags.Usage = func() { docker.CmdHelp(stdin, stdout) }
|
||||
cmd, args := URLToCall(r.URL)
|
||||
if err := flags.Parse(append([]string{cmd}, args...)); err != nil {
|
||||
return
|
||||
if err := flags.Parse(args); err != nil {
|
||||
return err
|
||||
}
|
||||
log.Printf("%s\n", strings.Join(append(append([]string{"docker"}, cmd), args...), " "))
|
||||
cmd := flags.Arg(0)
|
||||
log.Printf("%s\n", strings.Join(append(append([]string{"docker"}, cmd), args[1:]...), " "))
|
||||
if cmd == "" {
|
||||
cmd = "help"
|
||||
} else if cmd == "web" {
|
||||
w.Header().Set("content-type", "text/html")
|
||||
}
|
||||
method := docker.getMethod(cmd)
|
||||
if method == nil {
|
||||
fmt.Fprintf(stdout, "Error: no such command: %s\n", cmd)
|
||||
} else {
|
||||
err := method(stdin, stdout, args...)
|
||||
if err != nil {
|
||||
fmt.Fprintf(stdout, "Error: %s\n", err)
|
||||
if method != nil {
|
||||
return method(stdin, stdout, args[1:]...)
|
||||
}
|
||||
return errors.New("No such command: " + cmd)
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdMirror(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
_, err := io.Copy(stdout, stdin)
|
||||
return err
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdDebug(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
for {
|
||||
if line, err := bufio.NewReader(stdin).ReadString('\n'); err == nil {
|
||||
fmt.Printf("--- %s", line)
|
||||
} else if err == io.EOF {
|
||||
if len(line) > 0 {
|
||||
fmt.Printf("--- %s\n", line)
|
||||
}
|
||||
break
|
||||
} else {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (docker *Docker) CmdWeb(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
|
||||
|
|
@ -565,41 +563,41 @@ func Go(f func() error) chan error {
|
|||
}
|
||||
|
||||
type Docker struct {
|
||||
layers map[string]*Layer
|
||||
layersByName map[string]*ByDate
|
||||
containers map[string]Container
|
||||
}
|
||||
|
||||
type Layer struct {
|
||||
Id string
|
||||
Name string
|
||||
Added time.Time
|
||||
Size uint
|
||||
Source string
|
||||
containers map[string]*Container
|
||||
containersByName map[string]*ByDate
|
||||
}
|
||||
|
||||
type Container struct {
|
||||
Id string
|
||||
Cmd string
|
||||
Args []string
|
||||
Layers []*Layer
|
||||
Name string
|
||||
Created time.Time
|
||||
Source string
|
||||
Size uint
|
||||
FilesChanged uint
|
||||
BytesChanged uint
|
||||
Running bool
|
||||
Cmd string
|
||||
Args []string
|
||||
stdoutLog *bytes.Buffer
|
||||
stdinLog *bytes.Buffer
|
||||
}
|
||||
|
||||
func (c *Container) Run(stdin io.ReadCloser, stdout io.Writer) error {
|
||||
func (c *Container) Run(command string, args []string, stdin io.ReadCloser, stdout io.Writer) error {
|
||||
// Not thread-safe
|
||||
if c.Running {
|
||||
return errors.New("Already running")
|
||||
}
|
||||
c.Cmd = command
|
||||
c.Args = args
|
||||
// Reset logs
|
||||
c.stdoutLog.Reset()
|
||||
c.stdinLog.Reset()
|
||||
c.Running = true
|
||||
defer func() { c.Running = false }()
|
||||
cmd := exec.Command(c.Cmd, c.Args...)
|
||||
cmd_stdin, cmd_stdout, err := startCommand(cmd, false)
|
||||
cmd_stdin, cmd_stdout, err := startCommand(cmd, true)
|
||||
// ADD FAKE RANDOM CHANGES
|
||||
c.FilesChanged = uint(rand.Int31n(42))
|
||||
c.BytesChanged = uint(rand.Int31n(24 * 1024 * 1024))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -607,20 +605,27 @@ func (c *Container) Run(stdin io.ReadCloser, stdout io.Writer) error {
|
|||
_, err := io.Copy(io.MultiWriter(stdout, c.stdoutLog), cmd_stdout)
|
||||
return err
|
||||
})
|
||||
copy_in := Go(func() error {
|
||||
//_, err := io.Copy(io.MultiWriter(cmd_stdin, c.stdinLog), stdin)
|
||||
Go(func() error {
|
||||
_, err := io.Copy(io.MultiWriter(cmd_stdin, c.stdinLog), stdin)
|
||||
cmd_stdin.Close()
|
||||
stdin.Close()
|
||||
//return err
|
||||
return nil
|
||||
return err
|
||||
})
|
||||
if err := cmd.Wait(); err != nil {
|
||||
wait := Go(func() error {
|
||||
err := cmd.Wait()
|
||||
c.Running = false
|
||||
return err
|
||||
}
|
||||
if err := <-copy_in; err != nil {
|
||||
return err
|
||||
}
|
||||
})
|
||||
if err := <-copy_out; err != nil {
|
||||
if c.Running {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := <-wait; err != nil {
|
||||
if status, ok := err.(*exec.ExitError); ok {
|
||||
fmt.Fprintln(stdout, status)
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
|
|
|
|||
|
|
@ -188,7 +188,7 @@ b)}catch(f){i(f,"onCommandChange");throw f;}t()},commands:x});O.append(b);l.enab
|
|||
if (command !== '') {
|
||||
console.log(command);
|
||||
try {
|
||||
var url = "http://localhost:4242/" + command.split(" ")[0] + "?" + $.param(command.split(" ").slice(1).map(function(e) { return {name: "q", value: e} }))
|
||||
var url = "http://localhost:8080/" + command.split(" ")[0] + "?" + $.param(command.split(" ").slice(1).map(function(e) { return {name: "q", value: e} }))
|
||||
console.log(url);
|
||||
$.ajax(url).done(function(data) {
|
||||
term.echo(new String(data));
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue