Affinity labels like -e affinity:com.example.type==test

scheduler/filter/README.md

@@ -97,48 +97,65 @@ without specifying them when starting the node. Those tags are sourced from
 * kernelversion
 * operatingsystem
 
-## Affinity Filter
+## Affinity filter
 
-#### Containers
+You use an `--affinity:<filter>` to create "attractions" between containers. For
+example, you can run a container and instruct it to locate and run next to
+another container based on an identifier, an image, or a label. These
+attractions ensure that containers run on the same network node &mdash; without
+you having to know what each node is running.
 
-You can schedule 2 containers and make the container #2 next to the container #1.
+#### Container affinity
+
+You can schedule a new container to run next to another based on a container
+name or  ID.  For example, you can start a container called `frontend` running
+`nginx`:
 
 ```bash
 $ docker run -d -p 80:80 --name front nginx
  87c4376856a8
 
+
 $ docker ps
 CONTAINER ID        IMAGE               COMMAND             CREATED                  STATUS              PORTS                           NODE        NAMES
 87c4376856a8        nginx:latest        "nginx"             Less than a second ago   running             192.168.0.42:80->80/tcp         node-1      front
 ```
 
-Using `-e affinity:container==front` will schedule a container next to the container `front`.
-You can also use IDs instead of name: `-e affinity:container==87c4376856a8`
+Then, using `-e affinity:container==frontend` flag schedule a second container to
+locate and run next to `frontend`.
 
 ```bash
-$ docker run -d --name logger -e affinity:container==front logger
+$ docker run -d --name logger -e affinity:container==frontend logger
  87c4376856a8
 
 $ docker ps
 CONTAINER ID        IMAGE               COMMAND             CREATED                  STATUS              PORTS                           NODE        NAMES
-87c4376856a8        nginx:latest        "nginx"             Less than a second ago   running             192.168.0.42:80->80/tcp         node-1      front
+87c4376856a8        nginx:latest        "nginx"             Less than a second ago   running             192.168.0.42:80->80/tcp         node-1      frontend
 963841b138d8        logger:latest       "logger"            Less than a second ago   running                                             node-1      logger
 ```
 
-The `logger` container ends up on `node-1` because its affinity with the container `front`.
+Because of name affinity, the  `logger` container ends up on `node-1` along with
+the `frontend` container. Instead of the `frontend` name you could have supplied its
+ID as follows:
+
+```bash
+docker run -d --name logger -e affinity:container==87c4376856a8`
+```
+
 
-#### Images
+#### Image affinity
 
-You can schedule a container only on nodes where a specific image is already pulled.
+You can schedule a container to run only on nodes where a specific image is already pulled.
 
 ```bash
 $ docker -H node-1:2375 pull redis
 $ docker -H node-2:2375 pull mysql
 $ docker -H node-3:2375 pull redis
 ```
 
-Here only `node-1` and `node-3` have the `redis` image. Using `-e affinity:image=redis` we can
-schedule container only on these 2 nodes. You can also use the image ID instead of its name.
+Only `node-1` and `node-3` have the `redis` image. Specify a `-e
+affinity:image=redis` filter to schedule several additional containers to run on
+these nodes.
 
 ```bash
 $ docker run -d --name redis1 -e affinity:image==redis redis
@@ -162,7 +179,46 @@ CONTAINER ID        IMAGE               COMMAND             CREATED
 963841b138d8        redis:latest        "redis"             Less than a second ago   running                                             node-1      redis8
 ```
 
-As you can see here, the containers were only scheduled on nodes with the `redis` image already pulled.
+As you can see here, the containers were only scheduled on nodes that had the
+`redis` image. Instead of the image name, you could have specified the image ID.
+
+```bash
+$ docker images
+REPOSITORY                         TAG                       IMAGE ID            CREATED             VIRTUAL SIZE
+redis                              latest                    06a1f75304ba        2 days ago          111.1 MB
+
+$ docker run -d --name redis1 -e affinity:image==06a1f75304ba redis
+```
+
+
+#### Label affinity
+
+Label affinity allows you to set up an attraction based on a container's label.
+For example, you can run a `nginx` container with the `com.example.type=frontend` label.
+
+```bash
+$ docker run -d -p 80:80 --label com.example.type=frontend nginx
+ 87c4376856a8
+
+$ docker ps  --filter "label=com.example.type=front"
+CONTAINER ID        IMAGE               COMMAND             CREATED                  STATUS              PORTS                           NODE        NAMES
+87c4376856a8        nginx:latest        "nginx"             Less than a second ago   running             192.168.0.42:80->80/tcp         node-1      trusting_yonath
+```
+
+Then, use  `-e affinity:com.example.type==frontend` to schedule a container next to
+the container with the `com.example.type==frontend` label.
+
+```bash
+$ docker run -d -e affinity:com.example.type==frontend logger
+ 87c4376856a8
+
+$ docker ps
+CONTAINER ID        IMAGE               COMMAND             CREATED                  STATUS              PORTS                           NODE        NAMES
+87c4376856a8        nginx:latest        "nginx"             Less than a second ago   running             192.168.0.42:80->80/tcp         node-1      trusting_yonath
+963841b138d8        logger:latest       "logger"            Less than a second ago   running                                             node-1      happy_hawking
+```
+
+The `logger` container ends up on `node-1` because its affinity with the `com.example.type==frontend` label.
 
 #### Expression Syntax
 

scheduler/filter/affinity.go

@@ -51,6 +51,15 @@ func (f *AffinityFilter) Filter(config *dockerclient.ContainerConfig, nodes []*n
 				if affinity.Match(images...) {
 					candidates = append(candidates, node)
 				}
+			default:
+				labels := []string{}
+				for _, container := range node.Containers {
+					labels = append(labels, container.Labels[affinity.key])
+				}
+				if affinity.Match(labels...) {
+					candidates = append(candidates, node)
+				}
+
 			}
 		}
 		if len(candidates) == 0 {

scheduler/filter/expr.go

@@ -38,7 +38,7 @@ func parseExprs(key string, env []string) ([]expr, error) {
 
 					// validate key
 					// allow alpha-numeric
-					matched, err := regexp.MatchString(`^(?i)[a-z_][a-z0-9\-_]+$`, parts[0])
+					matched, err := regexp.MatchString(`^(?i)[a-z_][a-z0-9\-_.]+$`, parts[0])
 					if err != nil {
 						return nil, err
 					}

scheduler/filter/expr_test.go

@@ -15,14 +15,22 @@ func TestParseExprs(t *testing.T) {
 	_, err = parseExprs("constraint", []string{"constraint:node ==node1"})
 	assert.Error(t, err)
 
-	// Cannot use dot in key
-	_, err = parseExprs("constraint", []string{"constraint:no.de==node1"})
-	assert.Error(t, err)
-
 	// Cannot use * in key
 	_, err = parseExprs("constraint", []string{"constraint:no*de==node1"})
 	assert.Error(t, err)
 
+	// Cannot use $ in key
+	_, err = parseExprs("constraint", []string{"constraint:no$de==node1"})
+	assert.Error(t, err)
+
+	// Allow CAPS in key
+	_, err = parseExprs("constraint", []string{"constraint:NoDe==node1"})
+	assert.NoError(t, err)
+
+	// Allow dot in key
+	_, err = parseExprs("constraint", []string{"constraint:no.de==node1"})
+	assert.NoError(t, err)
+
 	// Allow leading underscore
 	_, err = parseExprs("constraint", []string{"constraint:_node==_node1"})
 	assert.NoError(t, err)

test/integration/affinities.bats

@@ -0,0 +1,76 @@
+#!/usr/bin/env bats
+
+load helpers
+
+function teardown() {
+	swarm_manage_cleanup
+	stop_docker
+}
+
+@test "container affinty" {
+	start_docker 2
+	swarm_manage
+
+	run docker_swarm run --name c1 -e constraint:node==node-0 -d busybox:latest sh
+	[ "$status" -eq 0 ]
+	run docker_swarm run --name c2 -e affinity:container==c1 -d busybox:latest sh
+	[ "$status" -eq 0 ]
+	run docker_swarm run --name c3 -e affinity:container!=c1 -d busybox:latest sh
+	[ "$status" -eq 0 ]
+
+	run docker_swarm inspect c1
+	[ "$status" -eq 0 ]
+	[[ "${output}" == *'"Name": "node-0"'* ]]
+
+	run docker_swarm inspect c2
+	[ "$status" -eq 0 ]
+	[[ "${output}" == *'"Name": "node-0"'* ]]
+
+	run docker_swarm inspect c3
+	[ "$status" -eq 0 ]
+	[[ "${output}" != *'"Name": "node-0"'* ]]
+}
+
+@test "image affinity" {
+      start_docker 2
+      swarm_manage
+
+      run docker -H ${HOSTS[0]} pull busybox
+      [ "$status" -eq 0 ]
+      run docker_swarm run --name c1 -e affinity:image==busybox -d busybox:latest sh
+      [ "$status" -eq 0 ]
+      run docker_swarm run --name c2 -e affinity:image!=busybox -d busybox:latest sh
+      [ "$status" -eq 0 ]
+
+      run docker_swarm inspect c1
+      [ "$status" -eq 0 ]
+      [[ "${output}" == *'"Name": "node-0"'* ]]
+
+      run docker_swarm inspect c2
+      [ "$status" -eq 0 ]
+      [[ "${output}" != *'"Name": "node-0"'* ]]
+}
+
+@test "label affinity" {
+	start_docker 2
+	swarm_manage
+
+	run docker_swarm run --name c1 --label test.label=true -e constraint:node==node-0 -d busybox:latest sh
+	[ "$status" -eq 0 ]
+	run docker_swarm run --name c2 -e affinity:test.label==true -d busybox:latest sh
+	[ "$status" -eq 0 ]
+	run docker_swarm run --name c3 -e affinity:test.label!=true -d busybox:latest sh
+	[ "$status" -eq 0 ]
+
+	run docker_swarm inspect c1
+	[ "$status" -eq 0 ]
+	[[ "${output}" == *'"Name": "node-0"'* ]]
+
+	run docker_swarm inspect c2
+	[ "$status" -eq 0 ]
+	[[ "${output}" == *'"Name": "node-0"'* ]]
+
+	run docker_swarm inspect c3
+	[ "$status" -eq 0 ]
+	[[ "${output}" != *'"Name": "node-0"'* ]]
+}

test/integration/helpers.bash

@@ -4,8 +4,8 @@
 SWARM_ROOT=${SWARM_ROOT:-${BATS_TEST_DIRNAME}/../..}
 
 # Docker image and version to use for integration tests.
-DOCKER_IMAGE=${DOCKER_IMAGE:-aluzzardi/docker}
-DOCKER_VERSION=${DOCKER_VERSION:-1.5}
+DOCKER_IMAGE=${DOCKER_IMAGE:-dockerswarm/docker}
+DOCKER_VERSION=${DOCKER_VERSION:-1.6}
 
 # Host on which the manager will listen to (random port between 6000 and 7000).
 SWARM_HOST=127.0.0.1:$(( ( RANDOM % 1000 )  + 6000 ))