Support more filters in network list operations

This is necessary when doing `docker stack rm` in Docker 1.13+ engines, because
the CLI client deletes networks by doing a network list call with a label
filter and then deleting everything that gets returned. If you do this against
Swarm, then you wind up deleting all of your networks.

Signed-off-by: Wayne Song <[email protected]>

Author: Wayne Song

api/handlers.go

@@ -277,7 +277,7 @@ func getNetworks(c *context, w http.ResponseWriter, r *http.Request) {
 	}
 
 	out := []*apitypes.NetworkResource{}
-	networks := c.cluster.Networks().Filter(filters.Get("name"), filters.Get("id"), types)
+	networks := c.cluster.Networks().Filter(filters)
 	for _, network := range networks {
 		tmp := (*network).NetworkResource
 		if tmp.Scope == "local" {

cluster/network.go

@@ -4,6 +4,7 @@ import (
 	"strings"
 
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/pkg/stringid"
 )
 
@@ -45,35 +46,43 @@ func (networks Networks) Uniq() Networks {
 	return uniq
 }
 
-// Filter returns networks filtered by names or ids
-func (networks Networks) Filter(names []string, ids []string, types []string) Networks {
-	typeFilter := func(network *Network) bool {
-		if len(types) > 0 {
-			for _, typ := range types {
-				if typ == "custom" && !network.isPreDefined() {
-					return true
-				}
-				if typ == "builtin" && network.isPreDefined() {
-					return true
-				}
+// Filter returns networks filtered by names, IDs, labels, etc.
+func (networks Networks) Filter(filter filters.Args) Networks {
+	includeFilter := func(network *Network) bool {
+		for _, typ := range filter.Get("type") {
+			if typ == "custom" && network.isPreDefined() {
+				return false
+			}
+			if typ == "builtin" && !network.isPreDefined() {
+				return false
+			}
+		}
+		if filter.Include("label") {
+			if !filter.MatchKVList("label", network.Labels) {
+				return false
+			}
+		}
+		if filter.Include("driver") {
+			if !filter.ExactMatch("driver", network.Driver) {
+				return false
 			}
-		} else {
-			return true
 		}
-		return false
+		return true
 	}
 
+	names := filter.Get("name")
+	ids := filter.Get("id")
 	out := Networks{}
 	if len(names) == 0 && len(ids) == 0 {
 		for _, network := range networks.Uniq() {
-			if typeFilter(network) {
+			if includeFilter(network) {
 				out = append(out, network)
 			}
 		}
 	} else {
 		for _, idOrName := range append(names, ids...) {
 			if network := networks.Get(idOrName); network != nil {
-				if typeFilter(network) {
+				if includeFilter(network) {
 					out = append(out, network)
 				}
 			}

cluster/network_test.go

@@ -1,38 +1,76 @@
 package cluster
 
 import (
+	"sort"
 	"testing"
 
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestNetworksFilter(t *testing.T) {
 	engine := &Engine{ID: "id"}
 	networks := Networks{
 		{types.NetworkResource{
-			ID:   "ababababab",
-			Name: "something",
+			ID:     "ababababab",
+			Name:   "something",
+			Driver: "overlay",
+			Labels: map[string]string{"testlabel": "testvalue1"},
 		}, engine},
 		{types.NetworkResource{
-			ID:   "aaaaaaaaaa1",
-			Name: "network_name",
+			ID:     "aaaaaaaaaa1",
+			Name:   "network_name",
+			Driver: "bridge",
+			Labels: map[string]string{"testlabel": "testvalue2"},
 		}, engine},
 		{types.NetworkResource{
-			ID:   "bbbbbbbbbb",
-			Name: "somethingelse",
+			ID:     "bbbbbbbbbb",
+			Name:   "somethingelse",
+			Driver: "overlay",
+			Labels: map[string]string{"testlabel": "testvalue3"},
 		}, engine},
 		{types.NetworkResource{
-			ID:   "aaaaaaaaa2",
-			Name: "foo",
+			ID:     "aaaaaaaaaa2",
+			Name:   "host",
+			Driver: "bridge",
 		}, engine},
 	}
 
-	filtered := networks.Filter([]string{"network_name"}, []string{"abababab"}, nil)
-	assert.Equal(t, len(filtered), 2)
-	for _, network := range filtered {
-		assert.True(t, network.ID == "aaaaaaaaaa1" || network.ID == "ababababab")
+	checkNetworks := func(t *testing.T, filtered Networks, expectedIDs ...string) {
+		sort.Strings(expectedIDs)
+		foundIDs := []string{}
+		for _, network := range filtered {
+			foundIDs = append(foundIDs, network.ID)
+		}
+		sort.Strings(foundIDs)
+		assert.Equal(t, expectedIDs, foundIDs)
 	}
+
+	filter := filters.NewArgs()
+	filter.Add("name", "network_name")
+	filter.Add("id", "abababab")
+	checkNetworks(t, networks.Filter(filter), "aaaaaaaaaa1", "ababababab")
+
+	filter = filters.NewArgs()
+	filter.Add("type", "builtin")
+	checkNetworks(t, networks.Filter(filter), "aaaaaaaaaa2")
+
+	filter = filters.NewArgs()
+	filter.Add("type", "custom")
+	checkNetworks(t, networks.Filter(filter), "aaaaaaaaaa1", "ababababab", "bbbbbbbbbb")
+
+	filter = filters.NewArgs()
+	filter.Add("driver", "overlay")
+	checkNetworks(t, networks.Filter(filter), "ababababab", "bbbbbbbbbb")
+
+	filter = filters.NewArgs()
+	filter.Add("label", "testlabel")
+	checkNetworks(t, networks.Filter(filter), "aaaaaaaaaa1", "ababababab", "bbbbbbbbbb")
+
+	filter = filters.NewArgs()
+	filter.Add("label", "testlabel=testvalue1")
+	checkNetworks(t, networks.Filter(filter), "ababababab")
 }
 
 func TestNetworkUniq(t *testing.T) {