Push image merge

README.md

@@ -4,7 +4,9 @@ Docker client library in Go
 
 Well maintained docker client library.
 
-Example:
+# How to use it?
+
+Here is an example showing how to use it:
 
 ```go
 package main
@@ -25,7 +27,7 @@ func main() {
 	docker, _ := dockerclient.NewDockerClient("unix:///var/run/docker.sock", nil)
 
 	// Get only running containers
-	containers, err := docker.ListContainers(false)
+	containers, err := docker.ListContainers(false, false, "")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -41,14 +43,19 @@ func main() {
 	}
 
 	// Create a container
-	containerConfig := &dockerclient.ContainerConfig{Image: "ubuntu:12.04", Cmd: []string{"bash"}}
-	containerId, err := docker.CreateContainer(containerConfig)
+	containerConfig := &dockerclient.ContainerConfig{
+		Image: "ubuntu:14.04",
+		Cmd:   []string{"bash"},
+		AttachStdin: true,
+		Tty:   true}
+	containerId, err := docker.CreateContainer(containerConfig, "foobar")
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Start the container
-	err = docker.StartContainer(containerId)
+	hostConfig := &dockerclient.HostConfig{}
+	err = docker.StartContainer(containerId, hostConfig)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -58,6 +65,19 @@ func main() {
 
 	// Listen to events
 	docker.StartMonitorEvents(eventCallback, nil)
+
+	// Hold the execution to look at the events coming
 	time.Sleep(3600 * time.Second)
 }
 ```
+
+# Maintainers
+
+List of people you can ping for feedback on Pull Requests or any questions.
+
+- [Sam Alba](https://github.com/samalba)
+- [Michael Crosby](https://github.com/crosbymichael)
+- [Andrea Luzzardi](https://github.com/aluzzardi)
+- [Victor Vieux](https://github.com/vieux)
+- [Evan Hazlett](https://github.com/ehazlett)
+- [Donald Huang](https://github.com/donhcd)

dockerclient.go

@@ -66,7 +66,25 @@ func NewDockerClientTimeout(daemonUrl string, tlsConfig *tls.Config, timeout tim
 
 func (client *DockerClient) doRequest(method string, path string, body []byte, headers map[string]string) ([]byte, error) {
 	b := bytes.NewBuffer(body)
-	req, err := http.NewRequest(method, client.URL.String()+path, b)
+
+	reader, err := client.doStreamRequest(method, path, b, headers)
+	if err != nil {
+		return nil, err
+	}
+
+	defer reader.Close()
+	data, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func (client *DockerClient) doStreamRequest(method string, path string, in io.Reader, headers map[string]string) (io.ReadCloser, error) {
+	if (method == "POST" || method == "PUT") && in == nil {
+		in = bytes.NewReader(nil)
+	}
+	req, err := http.NewRequest(method, client.URL.String()+path, in)
 	if err != nil {
 		return nil, err
 	}
@@ -83,18 +101,19 @@ func (client *DockerClient) doRequest(method string, path string, body []byte, h
 		}
 		return nil, err
 	}
-	defer resp.Body.Close()
-	data, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
 	if resp.StatusCode == 404 {
 		return nil, ErrNotFound
 	}
 	if resp.StatusCode >= 400 {
+		defer resp.Body.Close()
+		data, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return nil, err
+		}
 		return nil, Error{StatusCode: resp.StatusCode, Status: resp.Status, msg: string(data)}
 	}
-	return data, nil
+
+	return resp.Body, nil
 }
 
 func (client *DockerClient) Info() (*Info, error) {
@@ -212,6 +231,30 @@ func (client *DockerClient) ContainerChanges(id string) ([]*ContainerChanges, er
 	return changes, nil
 }
 
+func (client *DockerClient) readJSONStream(stream io.ReadCloser, decode func(*json.Decoder) decodingResult, stopChan <-chan struct{}) <-chan decodingResult {
+	resultChan := make(chan decodingResult)
+
+	go func() {
+		decoder := json.NewDecoder(stream)
+		defer stream.Close()
+		defer close(resultChan)
+		for {
+			decodeResult := decode(decoder)
+			select {
+			case <-stopChan:
+				return
+			default:
+				resultChan <- decodeResult
+				if decodeResult.err != nil {
+					return
+				}
+			}
+		}
+	}()
+
+	return resultChan
+}
+
 func (client *DockerClient) StartContainer(id string, config *HostConfig) error {
 	data, err := json.Marshal(config)
 	if err != nil {
@@ -252,6 +295,64 @@ func (client *DockerClient) KillContainer(id, signal string) error {
 	return nil
 }
 
+func (client *DockerClient) MonitorEvents(options *MonitorEventsOptions, stopChan <-chan struct{}) (<-chan EventOrError, error) {
+	v := url.Values{}
+	if options != nil {
+		if options.Since != 0 {
+			v.Add("since", strconv.Itoa(options.Since))
+		}
+		if options.Until != 0 {
+			v.Add("until", strconv.Itoa(options.Until))
+		}
+		if options.Filters != nil {
+			filterMap := make(map[string][]string)
+			if len(options.Filters.Event) > 0 {
+				filterMap["event"] = []string{options.Filters.Event}
+			}
+			if len(options.Filters.Image) > 0 {
+				filterMap["image"] = []string{options.Filters.Image}
+			}
+			if len(options.Filters.Container) > 0 {
+				filterMap["container"] = []string{options.Filters.Container}
+			}
+			if len(filterMap) > 0 {
+				filterJSONBytes, err := json.Marshal(filterMap)
+				if err != nil {
+					return nil, err
+				}
+				v.Add("filters", string(filterJSONBytes))
+			}
+		}
+	}
+	uri := fmt.Sprintf("%s/%s/events?%s", client.URL.String(), APIVersion, v.Encode())
+	resp, err := client.HTTPClient.Get(uri)
+	if err != nil {
+		return nil, err
+	}
+
+	decode := func(decoder *json.Decoder) decodingResult {
+		var event Event
+		if err := decoder.Decode(&event); err != nil {
+			return decodingResult{err: err}
+		} else {
+			return decodingResult{result: event}
+		}
+	}
+	decodingResultChan := client.readJSONStream(resp.Body, decode, stopChan)
+	eventOrErrorChan := make(chan EventOrError)
+	go func() {
+		for decodingResult := range decodingResultChan {
+			event, _ := decodingResult.result.(Event)
+			eventOrErrorChan <- EventOrError{
+				Event: event,
+				Error: decodingResult.err,
+			}
+		}
+		close(eventOrErrorChan)
+	}()
+	return eventOrErrorChan, nil
+}
+
 func (client *DockerClient) StartMonitorEvents(cb Callback, ec chan error, args ...interface{}) {
 	atomic.StoreInt32(&client.monitorEvents, 1)
 	go client.getEvents(cb, ec, args...)
@@ -310,6 +411,20 @@ func (client *DockerClient) StopAllMonitorStats() {
 	atomic.StoreInt32(&client.monitorStats, 0)
 }
 
+func (client *DockerClient) TagImage(nameOrID string, repo string, tag string, force bool) error {
+	v := url.Values{}
+	v.Set("repo", repo)
+	v.Set("tag", tag)
+	if force {
+		v.Set("force", "1")
+	}
+	uri := fmt.Sprintf("/%s/images/%s/tag?%s", APIVersion, nameOrID, v.Encode())
+	if _, err := client.doRequest("POST", uri, nil, nil); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (client *DockerClient) Version() (*Version, error) {
 	uri := fmt.Sprintf("/%s/version", APIVersion)
 	data, err := client.doRequest("GET", uri, nil, nil)
@@ -426,6 +541,34 @@ func (client *DockerClient) PullImage(name string, auth *AuthConfig) error {
 	return nil
 }
 
+func (client *DockerClient) InspectImage(id string) (*ImageInfo, error) {
+	uri := fmt.Sprintf("/%s/images/%s/json", APIVersion, id)
+	data, err := client.doRequest("GET", uri, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	info := &ImageInfo{}
+	err = json.Unmarshal(data, info)
+	if err != nil {
+		return nil, err
+	}
+	return info, nil
+}
+
+func (client *DockerClient) LoadImage(reader io.Reader) error {
+	data, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return err
+	}
+
+	uri := fmt.Sprintf("/%s/images/load", APIVersion)
+	_, err = client.doRequest("POST", uri, data, nil)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 func (client *DockerClient) RemoveContainer(id string, force, volumes bool) error {
 	argForce := 0
 	argVolumes := 0
@@ -507,3 +650,31 @@ func (client *DockerClient) Exec(config *ExecConfig) (string, error) {
 	}
 	return createExecResp.Id, nil
 }
+
+func (client *DockerClient) RenameContainer(oldName string, newName string) error {
+	uri := fmt.Sprintf("/containers/%s/rename?name=%s", oldName, newName)
+	_, err := client.doRequest("POST", uri, nil, nil)
+	return err
+}
+
+func (client *DockerClient) ImportImage(source string, repository string, tag string, tar io.Reader) (io.ReadCloser, error) {
+	var fromSrc string
+	v := &url.Values{}
+	if source == "" {
+		fromSrc = "-"
+	} else {
+		fromSrc = source
+	}
+
+	v.Set("fromSrc", fromSrc)
+	v.Set("repo", repository)
+	if tag != "" {
+		v.Set("tag", tag)
+	}
+
+	var in io.Reader
+	if fromSrc == "-" {
+		in = tar
+	}
+	return client.doStreamRequest("POST", "/images/create?"+v.Encode(), in, nil)
+}

dockerclient_test.go

@@ -2,7 +2,9 @@ package dockerclient
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
 	"reflect"
 	"strings"
 	"testing"
@@ -155,6 +157,58 @@ func TestContainerLogs(t *testing.T) {
 	}
 }
 
+func TestMonitorEvents(t *testing.T) {
+	client := testDockerClient(t)
+	decoder := json.NewDecoder(bytes.NewBufferString(eventsResp))
+	var expectedEvents []Event
+	for {
+		var event Event
+		if err := decoder.Decode(&event); err != nil {
+			if err == io.EOF {
+				break
+			} else {
+				t.Fatalf("cannot parse expected resp: %s", err.Error())
+			}
+		} else {
+			expectedEvents = append(expectedEvents, event)
+		}
+	}
+
+	// test passing stop chan
+	stopChan := make(chan struct{})
+	eventInfoChan, err := client.MonitorEvents(nil, stopChan)
+	if err != nil {
+		t.Fatalf("cannot get events from server: %s", err.Error())
+	}
+
+	eventInfo := <-eventInfoChan
+	if eventInfo.Error != nil || eventInfo.Event != expectedEvents[0] {
+		t.Fatalf("got:\n%#v\nexpected:\n%#v", eventInfo, expectedEvents[0])
+	}
+	close(stopChan)
+	for i := 0; i < 3; i++ {
+		_, ok := <-eventInfoChan
+		if i == 2 && ok {
+			t.Fatalf("read more than 2 events successfully after closing stopChan")
+		}
+	}
+
+	// test when you don't pass stop chan
+	eventInfoChan, err = client.MonitorEvents(nil, nil)
+	if err != nil {
+		t.Fatalf("cannot get events from server: %s", err.Error())
+	}
+
+	for i, expectedEvent := range expectedEvents {
+		t.Logf("on iter %d\n", i)
+		eventInfo := <-eventInfoChan
+		if eventInfo.Error != nil || eventInfo.Event != expectedEvent {
+			t.Fatalf("index %d, got:\n%#v\nexpected:\n%#v", i, eventInfo, expectedEvent)
+		}
+		t.Logf("done with iter %d\n", i)
+	}
+}
+
 func TestDockerClientInterface(t *testing.T) {
 	iface := reflect.TypeOf((*Client)(nil)).Elem()
 	test := testDockerClient(t)