bump(fsouza/go-dockerclient): 42d06e2b125654477366c320dcea99107a86e9c2

2025-12-02 19:49:13 +00:00 · 2015-08-15 15:47:54 -04:00
parent 6afbaf6bf6
commit 594abd540f
21 changed files with 916 additions and 45 deletions
--- a/Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/server.go
+++ b/Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/server.go
@@ -43,6 +43,8 @@ type DockerServer struct {
 	images         []docker.Image
 	iMut           sync.RWMutex
 	imgIDs         map[string]string
+	networks       []*docker.Network
+	netMut         sync.RWMutex
 	listener       net.Listener
 	mux            *mux.Router
 	hook           func(*http.Request)
@@ -124,6 +126,9 @@ func (s *DockerServer) buildMuxer() {
 	s.mux.Path("/_ping").Methods("GET").HandlerFunc(s.handlerWrapper(s.pingDocker))
 	s.mux.Path("/images/load").Methods("POST").HandlerFunc(s.handlerWrapper(s.loadImage))
 	s.mux.Path("/images/{id:.*}/get").Methods("GET").HandlerFunc(s.handlerWrapper(s.getImage))
+	s.mux.Path("/networks").Methods("GET").HandlerFunc(s.handlerWrapper(s.listNetworks))
+	s.mux.Path("/networks/{id:.*}").Methods("GET").HandlerFunc(s.handlerWrapper(s.networkInfo))
+	s.mux.Path("/networks").Methods("POST").HandlerFunc(s.handlerWrapper(s.createNetwork))
 }

 // SetHook changes the hook function used by the server.
@@ -981,3 +986,77 @@ func (s *DockerServer) getExec(id string) (*docker.ExecInspect, error) {
 	}
 	return nil, errors.New("exec not found")
 }
+
+func (s *DockerServer) findNetwork(idOrName string) (*docker.Network, int, error) {
+	s.netMut.RLock()
+	defer s.netMut.RUnlock()
+	for i, network := range s.networks {
+		if network.ID == idOrName || network.Name == idOrName {
+			return network, i, nil
+		}
+	}
+	return nil, -1, errors.New("No such network")
+}
+
+func (s *DockerServer) listNetworks(w http.ResponseWriter, r *http.Request) {
+	s.netMut.RLock()
+	result := make([]docker.Network, 0, len(s.networks))
+	for _, network := range s.networks {
+		result = append(result, *network)
+	}
+	s.netMut.RUnlock()
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(result)
+}
+
+func (s *DockerServer) networkInfo(w http.ResponseWriter, r *http.Request) {
+	id := mux.Vars(r)["id"]
+	network, _, err := s.findNetwork(id)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusNotFound)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(network)
+}
+
+// isValidName validates configuration objects supported by libnetwork
+func isValidName(name string) bool {
+	if name == "" || strings.Contains(name, ".") {
+		return false
+	}
+	return true
+}
+
+func (s *DockerServer) createNetwork(w http.ResponseWriter, r *http.Request) {
+	var config *docker.CreateNetworkOptions
+	defer r.Body.Close()
+	err := json.NewDecoder(r.Body).Decode(&config)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if !isValidName(config.Name) {
+		http.Error(w, "Invalid network name", http.StatusBadRequest)
+		return
+	}
+	if n, _, _ := s.findNetwork(config.Name); n != nil {
+		http.Error(w, "network already exists", http.StatusForbidden)
+		return
+	}
+
+	generatedID := s.generateID()
+	network := docker.Network{
+		Name: config.Name,
+		ID:   generatedID,
+		Type: config.NetworkType,
+	}
+	s.netMut.Lock()
+	s.networks = append(s.networks, &network)
+	s.netMut.Unlock()
+	w.WriteHeader(http.StatusCreated)
+	var c = struct{ ID string }{ID: network.ID}
+	json.NewEncoder(w).Encode(c)
+}
--- a/Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/server_test.go
+++ b/Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/server_test.go
@@ -1679,3 +1679,106 @@ func TestStatsContainerStream(t *testing.T) {
 		t.Errorf("StatsContainer: wrong value. Want %#v. Got %#v.", expected, got)
 	}
 }
+
+func addNetworks(server *DockerServer, n int) {
+	server.netMut.Lock()
+	defer server.netMut.Unlock()
+	for i := 0; i < n; i++ {
+		netid := fmt.Sprintf("%x", rand.Int()%10000)
+		network := docker.Network{
+			Name: netid,
+			ID:   fmt.Sprintf("%x", rand.Int()%10000),
+			Type: "bridge",
+			Endpoints: []*docker.Endpoint{
+				&docker.Endpoint{
+					Name:    "blah",
+					ID:      fmt.Sprintf("%x", rand.Int()%10000),
+					Network: netid,
+				},
+			},
+		}
+		server.networks = append(server.networks, &network)
+	}
+}
+
+func TestListNetworks(t *testing.T) {
+	server := DockerServer{}
+	addNetworks(&server, 2)
+	server.buildMuxer()
+	recorder := httptest.NewRecorder()
+	request, _ := http.NewRequest("GET", "/networks", nil)
+	server.ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusOK {
+		t.Errorf("ListNetworks: wrong status. Want %d. Got %d.", http.StatusOK, recorder.Code)
+	}
+	expected := make([]docker.Network, 2)
+	for i, network := range server.networks {
+		expected[i] = docker.Network{
+			ID:        network.ID,
+			Name:      network.Name,
+			Type:      network.Type,
+			Endpoints: network.Endpoints,
+		}
+	}
+	var got []docker.Network
+	err := json.NewDecoder(recorder.Body).Decode(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(got, expected) {
+		t.Errorf("ListNetworks. Want %#v. Got %#v.", expected, got)
+	}
+}
+
+type createNetworkResponse struct {
+	ID string `json:"ID"`
+}
+
+func TestCreateNetwork(t *testing.T) {
+	server := DockerServer{}
+	server.buildMuxer()
+	recorder := httptest.NewRecorder()
+	netid := fmt.Sprintf("%x", rand.Int()%10000)
+	netname := fmt.Sprintf("%x", rand.Int()%10000)
+	body := fmt.Sprintf(`{"ID": "%s", "Name": "%s", "Type": "bridge" }`, netid, netname)
+	request, _ := http.NewRequest("POST", "/networks", strings.NewReader(body))
+	server.ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusCreated {
+		t.Errorf("CreateNetwork: wrong status. Want %d. Got %d.", http.StatusCreated, recorder.Code)
+	}
+
+	var returned createNetworkResponse
+	err := json.NewDecoder(recorder.Body).Decode(&returned)
+	if err != nil {
+		t.Fatal(err)
+	}
+	stored := server.networks[0]
+	if returned.ID != stored.ID {
+		t.Errorf("CreateNetwork: ID mismatch. Stored: %q. Returned: %q.", stored.ID, returned)
+	}
+}
+
+func TestCreateNetworkInvalidBody(t *testing.T) {
+	server := DockerServer{}
+	server.buildMuxer()
+	recorder := httptest.NewRecorder()
+	request, _ := http.NewRequest("POST", "/networks", strings.NewReader("whaaaaaat---"))
+	server.ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusBadRequest {
+		t.Errorf("CreateNetwork: wrong status. Want %d. Got %d.", http.StatusBadRequest, recorder.Code)
+	}
+}
+
+func TestCreateNetworkDuplicateName(t *testing.T) {
+	server := DockerServer{}
+	server.buildMuxer()
+	addNetworks(&server, 1)
+	server.networks[0].Name = "mynetwork"
+	recorder := httptest.NewRecorder()
+	body := fmt.Sprintf(`{"ID": "%s", "Name": "mynetwork", "Type": "bridge" }`, fmt.Sprintf("%x", rand.Int()%10000))
+	request, _ := http.NewRequest("POST", "/networks", strings.NewReader(body))
+	server.ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusForbidden {
+		t.Errorf("CreateNetwork: wrong status. Want %d. Got %d.", http.StatusForbidden, recorder.Code)
+	}
+}