- traefik.mycustomservice.port=443 - traefik.mycustomservice.frontend.rule=Path:/mycustomservice - traefik.anothercustomservice.port=8080 - traefik.anothercustomservice.frontend.rule=Path:/anotherservice all traffic to frontend /mycustomservice is redirected to the port 443 of the container while using /anotherservice will redirect to the port 8080 of the docker container More documentation in the docs/toml.md file Change-Id: Ifaa3bb00ef0a0f38aa189e0ca1586fde8c5ed862 Signed-off-by: Florent BENOIT <fbenoit@codenvy.com>
2883 lines
64 KiB
Go
2883 lines
64 KiB
Go
package provider
|
|
|
|
import (
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/containous/traefik/types"
|
|
docker "github.com/docker/engine-api/types"
|
|
"github.com/docker/engine-api/types/container"
|
|
"github.com/docker/engine-api/types/network"
|
|
"github.com/docker/engine-api/types/swarm"
|
|
"github.com/docker/go-connections/nat"
|
|
)
|
|
|
|
func TestDockerGetFrontendName(t *testing.T) {
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "Host-foo-docker-localhost",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "bar",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Headers:User-Agent,bat/0.1.0",
|
|
},
|
|
},
|
|
},
|
|
expected: "Headers-User-Agent-bat-0-1-0",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Host:foo.bar",
|
|
},
|
|
},
|
|
},
|
|
expected: "Host-foo-bar",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Path:/test",
|
|
},
|
|
},
|
|
},
|
|
expected: "Path-test",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "PathPrefix:/test2",
|
|
},
|
|
},
|
|
},
|
|
expected: "PathPrefix-test2",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getFrontendName(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetFrontendRule(t *testing.T) {
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "Host:foo.docker.localhost",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "bar",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "Host:bar.docker.localhost",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Host:foo.bar",
|
|
},
|
|
},
|
|
},
|
|
expected: "Host:foo.bar",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Path:/test",
|
|
},
|
|
},
|
|
},
|
|
expected: "Path:/test",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getFrontendRule(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetBackend(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "foo",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "bar",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "bar",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.backend": "foobar",
|
|
},
|
|
},
|
|
},
|
|
expected: "foobar",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getBackend(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetIPAddress(t *testing.T) { // TODO
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "bar",
|
|
},
|
|
Config: &container.Config{},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"testnet": {
|
|
IPAddress: "10.11.12.13",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "10.11.12.13",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "bar",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.docker.network": "testnet",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"nottestnet": {
|
|
IPAddress: "10.11.12.13",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "10.11.12.13",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "bar",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.docker.network": "testnet2",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"testnet1": {
|
|
IPAddress: "10.11.12.13",
|
|
},
|
|
"testnet2": {
|
|
IPAddress: "10.11.12.14",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "10.11.12.14",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "bar",
|
|
HostConfig: &container.HostConfig{
|
|
NetworkMode: "host",
|
|
},
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"testnet1": {
|
|
IPAddress: "10.11.12.13",
|
|
},
|
|
"testnet2": {
|
|
IPAddress: "10.11.12.14",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "127.0.0.1",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getIPAddress(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetPort(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
NetworkSettings: &docker.NetworkSettings{},
|
|
},
|
|
expected: "",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "bar",
|
|
},
|
|
Config: &container.Config{},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "80",
|
|
},
|
|
// FIXME handle this better..
|
|
// {
|
|
// container: docker.ContainerJSON{
|
|
// Name: "bar",
|
|
// Config: &container.Config{},
|
|
// NetworkSettings: &docker.NetworkSettings{
|
|
// Ports: map[docker.Port][]docker.PortBinding{
|
|
// "80/tcp": []docker.PortBinding{},
|
|
// "443/tcp": []docker.PortBinding{},
|
|
// },
|
|
// },
|
|
// },
|
|
// expected: "80",
|
|
// },
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.port": "8080",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{},
|
|
},
|
|
expected: "8080",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.port": "8080",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "8080",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test-multi-ports",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.port": "8080",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"8080/tcp": {},
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "8080",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getPort(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetWeight(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "0",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.weight": "10",
|
|
},
|
|
},
|
|
},
|
|
expected: "10",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getWeight(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetDomain(t *testing.T) {
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "docker.localhost",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.domain": "foo.bar",
|
|
},
|
|
},
|
|
},
|
|
expected: "foo.bar",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getDomain(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetProtocol(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "http",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.protocol": "https",
|
|
},
|
|
},
|
|
},
|
|
expected: "https",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getProtocol(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetPassHostHeader(t *testing.T) {
|
|
provider := &Docker{}
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "true",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.passHostHeader": "false",
|
|
},
|
|
},
|
|
},
|
|
expected: "false",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getPassHostHeader(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetLabel(t *testing.T) {
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "Label not found:",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
},
|
|
},
|
|
expected: "",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
label, err := getLabel(dockerData, "foo")
|
|
if e.expected != "" {
|
|
if err == nil || !strings.Contains(err.Error(), e.expected) {
|
|
t.Fatalf("expected an error with %q, got %v", e.expected, err)
|
|
}
|
|
} else {
|
|
if label != "bar" {
|
|
t.Fatalf("expected label 'bar', got %s", label)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetLabels(t *testing.T) {
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expectedLabels map[string]string
|
|
expectedError string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expectedLabels: map[string]string{},
|
|
expectedError: "Label not found:",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"foo": "fooz",
|
|
},
|
|
},
|
|
},
|
|
expectedLabels: map[string]string{
|
|
"foo": "fooz",
|
|
},
|
|
expectedError: "Label not found: bar",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"foo": "fooz",
|
|
"bar": "barz",
|
|
},
|
|
},
|
|
},
|
|
expectedLabels: map[string]string{
|
|
"foo": "fooz",
|
|
"bar": "barz",
|
|
},
|
|
expectedError: "",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
labels, err := getLabels(dockerData, []string{"foo", "bar"})
|
|
if !reflect.DeepEqual(labels, e.expectedLabels) {
|
|
t.Fatalf("expect %v, got %v", e.expectedLabels, labels)
|
|
}
|
|
if e.expectedError != "" {
|
|
if err == nil || !strings.Contains(err.Error(), e.expectedError) {
|
|
t.Fatalf("expected an error with %q, got %v", e.expectedError, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerTraefikFilter(t *testing.T) {
|
|
provider := Docker{}
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
exposedByDefault bool
|
|
expected bool
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{},
|
|
NetworkSettings: &docker.NetworkSettings{},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: false,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.enable": "false",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: false,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Host:foo.bar",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container-multi-ports",
|
|
},
|
|
Config: &container.Config{},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
"443/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
"443/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.enable": "true",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.enable": "anything",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Host:foo.bar",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: false,
|
|
expected: false,
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "container",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.enable": "true",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: false,
|
|
expected: true,
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
provider.ExposedByDefault = e.exposedByDefault
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.containerFilter(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %v for %+v, got %+v", e.expected, e, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerLoadDockerConfig(t *testing.T) {
|
|
cases := []struct {
|
|
containers []docker.ContainerJSON
|
|
expectedFrontends map[string]*types.Frontend
|
|
expectedBackends map[string]*types.Backend
|
|
}{
|
|
{
|
|
containers: []docker.ContainerJSON{},
|
|
expectedFrontends: map[string]*types.Frontend{},
|
|
expectedBackends: map[string]*types.Backend{},
|
|
},
|
|
{
|
|
containers: []docker.ContainerJSON{
|
|
{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"bridge": {
|
|
IPAddress: "127.0.0.1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedFrontends: map[string]*types.Frontend{
|
|
"frontend-Host-test-docker-localhost": {
|
|
Backend: "backend-test",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{},
|
|
Routes: map[string]types.Route{
|
|
"route-frontend-Host-test-docker-localhost": {
|
|
Rule: "Host:test.docker.localhost",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedBackends: map[string]*types.Backend{
|
|
"backend-test": {
|
|
Servers: map[string]types.Server{
|
|
"server-test": {
|
|
URL: "http://127.0.0.1:80",
|
|
Weight: 0,
|
|
},
|
|
},
|
|
CircuitBreaker: nil,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
containers: []docker.ContainerJSON{
|
|
{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test1",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.backend": "foobar",
|
|
"traefik.frontend.entryPoints": "http,https",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"bridge": {
|
|
IPAddress: "127.0.0.1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test2",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.backend": "foobar",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"bridge": {
|
|
IPAddress: "127.0.0.1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedFrontends: map[string]*types.Frontend{
|
|
"frontend-Host-test1-docker-localhost": {
|
|
Backend: "backend-foobar",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{"http", "https"},
|
|
Routes: map[string]types.Route{
|
|
"route-frontend-Host-test1-docker-localhost": {
|
|
Rule: "Host:test1.docker.localhost",
|
|
},
|
|
},
|
|
},
|
|
"frontend-Host-test2-docker-localhost": {
|
|
Backend: "backend-foobar",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{},
|
|
Routes: map[string]types.Route{
|
|
"route-frontend-Host-test2-docker-localhost": {
|
|
Rule: "Host:test2.docker.localhost",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedBackends: map[string]*types.Backend{
|
|
"backend-foobar": {
|
|
Servers: map[string]types.Server{
|
|
"server-test1": {
|
|
URL: "http://127.0.0.1:80",
|
|
Weight: 0,
|
|
},
|
|
"server-test2": {
|
|
URL: "http://127.0.0.1:80",
|
|
Weight: 0,
|
|
},
|
|
},
|
|
CircuitBreaker: nil,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
containers: []docker.ContainerJSON{
|
|
{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test1",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.backend": "foobar",
|
|
"traefik.frontend.entryPoints": "http,https",
|
|
"traefik.backend.maxconn.amount": "1000",
|
|
"traefik.backend.maxconn.extractorfunc": "somethingelse",
|
|
"traefik.backend.loadbalancer.method": "drr",
|
|
"traefik.backend.circuitbreaker.expression": "NetworkErrorRatio() > 0.5",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"bridge": {
|
|
IPAddress: "127.0.0.1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedFrontends: map[string]*types.Frontend{
|
|
"frontend-Host-test1-docker-localhost": {
|
|
Backend: "backend-foobar",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{"http", "https"},
|
|
Routes: map[string]types.Route{
|
|
"route-frontend-Host-test1-docker-localhost": {
|
|
Rule: "Host:test1.docker.localhost",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedBackends: map[string]*types.Backend{
|
|
"backend-foobar": {
|
|
Servers: map[string]types.Server{
|
|
"server-test1": {
|
|
URL: "http://127.0.0.1:80",
|
|
Weight: 0,
|
|
},
|
|
},
|
|
CircuitBreaker: &types.CircuitBreaker{
|
|
Expression: "NetworkErrorRatio() > 0.5",
|
|
},
|
|
LoadBalancer: &types.LoadBalancer{
|
|
Method: "drr",
|
|
},
|
|
MaxConn: &types.MaxConn{
|
|
Amount: 1000,
|
|
ExtractorFunc: "somethingelse",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
ExposedByDefault: true,
|
|
}
|
|
|
|
for _, c := range cases {
|
|
var dockerDataList []dockerData
|
|
for _, container := range c.containers {
|
|
dockerData := parseContainer(container)
|
|
dockerDataList = append(dockerDataList, dockerData)
|
|
}
|
|
|
|
actualConfig := provider.loadDockerConfig(dockerDataList)
|
|
// Compare backends
|
|
if !reflect.DeepEqual(actualConfig.Backends, c.expectedBackends) {
|
|
t.Fatalf("expected %#v, got %#v", c.expectedBackends, actualConfig.Backends)
|
|
}
|
|
if !reflect.DeepEqual(actualConfig.Frontends, c.expectedFrontends) {
|
|
t.Fatalf("expected %#v, got %#v", c.expectedFrontends, actualConfig.Frontends)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetFrontendName(t *testing.T) {
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "foo",
|
|
},
|
|
},
|
|
},
|
|
expected: "Host-foo-docker-localhost",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Headers:User-Agent,bat/0.1.0",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "Headers-User-Agent-bat-0-1-0",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Host:foo.bar",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "Host-foo-bar",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Path:/test",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "Path-test",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "PathPrefix:/test2",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "PathPrefix-test2",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getFrontendName(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetFrontendRule(t *testing.T) {
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "foo",
|
|
},
|
|
},
|
|
},
|
|
expected: "Host:foo.docker.localhost",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
},
|
|
},
|
|
},
|
|
expected: "Host:bar.docker.localhost",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Host:foo.bar",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "Host:foo.bar",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Path:/test",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "Path:/test",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getFrontendRule(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetBackend(t *testing.T) {
|
|
provider := &Docker{
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "foo",
|
|
},
|
|
},
|
|
},
|
|
expected: "foo",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
},
|
|
},
|
|
},
|
|
expected: "bar",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"traefik.backend": "foobar",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "foobar",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getBackend(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetIPAddress(t *testing.T) {
|
|
provider := &Docker{
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeVIP,
|
|
},
|
|
},
|
|
Endpoint: swarm.Endpoint{
|
|
VirtualIPs: []swarm.EndpointVirtualIP{
|
|
{
|
|
NetworkID: "1",
|
|
Addr: "10.11.12.13/24",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "10.11.12.13",
|
|
networks: map[string]*docker.NetworkResource{
|
|
"1": {
|
|
Name: "foo",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
Labels: map[string]string{
|
|
"traefik.docker.network": "barnet",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeVIP,
|
|
},
|
|
},
|
|
Endpoint: swarm.Endpoint{
|
|
VirtualIPs: []swarm.EndpointVirtualIP{
|
|
{
|
|
NetworkID: "1",
|
|
Addr: "10.11.12.13/24",
|
|
},
|
|
{
|
|
NetworkID: "2",
|
|
Addr: "10.11.12.99/24",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "10.11.12.99",
|
|
networks: map[string]*docker.NetworkResource{
|
|
"1": {
|
|
Name: "foonet",
|
|
},
|
|
"2": {
|
|
Name: "barnet",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getIPAddress(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetPort(t *testing.T) {
|
|
provider := &Docker{
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
Labels: map[string]string{
|
|
"traefik.port": "8080",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "8080",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getPort(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetWeight(t *testing.T) {
|
|
provider := &Docker{
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "0",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
Labels: map[string]string{
|
|
"traefik.weight": "10",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "10",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getWeight(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetDomain(t *testing.T) {
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "foo",
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "docker.localhost",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
Labels: map[string]string{
|
|
"traefik.domain": "foo.bar",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "foo.bar",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getDomain(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetProtocol(t *testing.T) {
|
|
provider := &Docker{
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "http",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
Labels: map[string]string{
|
|
"traefik.protocol": "https",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "https",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getProtocol(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetPassHostHeader(t *testing.T) {
|
|
provider := &Docker{
|
|
SwarmMode: true,
|
|
}
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "true",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.passHostHeader": "false",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "false",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
actual := provider.getPassHostHeader(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetLabel(t *testing.T) {
|
|
|
|
services := []struct {
|
|
service swarm.Service
|
|
expected string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "bar",
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "Label not found:",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeDNSRR,
|
|
},
|
|
},
|
|
},
|
|
expected: "",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
label, err := getLabel(dockerData, "foo")
|
|
if e.expected != "" {
|
|
if err == nil || !strings.Contains(err.Error(), e.expected) {
|
|
t.Fatalf("expected an error with %q, got %v", e.expected, err)
|
|
}
|
|
} else {
|
|
if label != "bar" {
|
|
t.Fatalf("expected label 'bar', got %s", label)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmGetLabels(t *testing.T) {
|
|
services := []struct {
|
|
service swarm.Service
|
|
expectedLabels map[string]string
|
|
expectedError string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
},
|
|
},
|
|
},
|
|
expectedLabels: map[string]string{},
|
|
expectedError: "Label not found:",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"foo": "fooz",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedLabels: map[string]string{
|
|
"foo": "fooz",
|
|
},
|
|
expectedError: "Label not found: bar",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"foo": "fooz",
|
|
"bar": "barz",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedLabels: map[string]string{
|
|
"foo": "fooz",
|
|
"bar": "barz",
|
|
},
|
|
expectedError: "",
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
labels, err := getLabels(dockerData, []string{"foo", "bar"})
|
|
if !reflect.DeepEqual(labels, e.expectedLabels) {
|
|
t.Fatalf("expect %v, got %v", e.expectedLabels, labels)
|
|
}
|
|
if e.expectedError != "" {
|
|
if err == nil || !strings.Contains(err.Error(), e.expectedError) {
|
|
t.Fatalf("expected an error with %q, got %v", e.expectedError, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmTraefikFilter(t *testing.T) {
|
|
provider := &Docker{
|
|
SwarmMode: true,
|
|
}
|
|
services := []struct {
|
|
service swarm.Service
|
|
exposedByDefault bool
|
|
expected bool
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: false,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
Labels: map[string]string{
|
|
"traefik.enable": "false",
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: false,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Host:foo.bar",
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
Labels: map[string]string{
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
Labels: map[string]string{
|
|
"traefik.enable": "true",
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
Labels: map[string]string{
|
|
"traefik.enable": "anything",
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Host:foo.bar",
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
Labels: map[string]string{
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: false,
|
|
expected: false,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
Labels: map[string]string{
|
|
"traefik.enable": "true",
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
exposedByDefault: false,
|
|
expected: true,
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
}
|
|
|
|
for _, e := range services {
|
|
dockerData := parseService(e.service, e.networks)
|
|
provider.ExposedByDefault = e.exposedByDefault
|
|
actual := provider.containerFilter(dockerData)
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %v for %+v, got %+v", e.expected, e, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmLoadDockerConfig(t *testing.T) {
|
|
cases := []struct {
|
|
services []swarm.Service
|
|
expectedFrontends map[string]*types.Frontend
|
|
expectedBackends map[string]*types.Backend
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
services: []swarm.Service{},
|
|
expectedFrontends: map[string]*types.Frontend{},
|
|
expectedBackends: map[string]*types.Backend{},
|
|
networks: map[string]*docker.NetworkResource{},
|
|
},
|
|
{
|
|
services: []swarm.Service{
|
|
{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test",
|
|
Labels: map[string]string{
|
|
"traefik.port": "80",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeVIP,
|
|
},
|
|
},
|
|
Endpoint: swarm.Endpoint{
|
|
VirtualIPs: []swarm.EndpointVirtualIP{
|
|
{
|
|
Addr: "127.0.0.1/24",
|
|
NetworkID: "1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedFrontends: map[string]*types.Frontend{
|
|
"frontend-Host-test-docker-localhost": {
|
|
Backend: "backend-test",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{},
|
|
Routes: map[string]types.Route{
|
|
"route-frontend-Host-test-docker-localhost": {
|
|
Rule: "Host:test.docker.localhost",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedBackends: map[string]*types.Backend{
|
|
"backend-test": {
|
|
Servers: map[string]types.Server{
|
|
"server-test": {
|
|
URL: "http://127.0.0.1:80",
|
|
Weight: 0,
|
|
},
|
|
},
|
|
CircuitBreaker: nil,
|
|
LoadBalancer: nil,
|
|
},
|
|
},
|
|
networks: map[string]*docker.NetworkResource{
|
|
"1": {
|
|
Name: "foo",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
services: []swarm.Service{
|
|
{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test1",
|
|
Labels: map[string]string{
|
|
"traefik.port": "80",
|
|
"traefik.backend": "foobar",
|
|
"traefik.frontend.entryPoints": "http,https",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeVIP,
|
|
},
|
|
},
|
|
Endpoint: swarm.Endpoint{
|
|
VirtualIPs: []swarm.EndpointVirtualIP{
|
|
{
|
|
Addr: "127.0.0.1/24",
|
|
NetworkID: "1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "test2",
|
|
Labels: map[string]string{
|
|
"traefik.port": "80",
|
|
"traefik.backend": "foobar",
|
|
},
|
|
},
|
|
EndpointSpec: &swarm.EndpointSpec{
|
|
Mode: swarm.ResolutionModeVIP,
|
|
},
|
|
},
|
|
Endpoint: swarm.Endpoint{
|
|
VirtualIPs: []swarm.EndpointVirtualIP{
|
|
{
|
|
Addr: "127.0.0.1/24",
|
|
NetworkID: "1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedFrontends: map[string]*types.Frontend{
|
|
"frontend-Host-test1-docker-localhost": {
|
|
Backend: "backend-foobar",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{"http", "https"},
|
|
Routes: map[string]types.Route{
|
|
"route-frontend-Host-test1-docker-localhost": {
|
|
Rule: "Host:test1.docker.localhost",
|
|
},
|
|
},
|
|
},
|
|
"frontend-Host-test2-docker-localhost": {
|
|
Backend: "backend-foobar",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{},
|
|
Routes: map[string]types.Route{
|
|
"route-frontend-Host-test2-docker-localhost": {
|
|
Rule: "Host:test2.docker.localhost",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedBackends: map[string]*types.Backend{
|
|
"backend-foobar": {
|
|
Servers: map[string]types.Server{
|
|
"server-test1": {
|
|
URL: "http://127.0.0.1:80",
|
|
Weight: 0,
|
|
},
|
|
"server-test2": {
|
|
URL: "http://127.0.0.1:80",
|
|
Weight: 0,
|
|
},
|
|
},
|
|
CircuitBreaker: nil,
|
|
LoadBalancer: nil,
|
|
},
|
|
},
|
|
networks: map[string]*docker.NetworkResource{
|
|
"1": {
|
|
Name: "foo",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
ExposedByDefault: true,
|
|
SwarmMode: true,
|
|
}
|
|
|
|
for _, c := range cases {
|
|
var dockerDataList []dockerData
|
|
for _, service := range c.services {
|
|
dockerData := parseService(service, c.networks)
|
|
dockerDataList = append(dockerDataList, dockerData)
|
|
}
|
|
|
|
actualConfig := provider.loadDockerConfig(dockerDataList)
|
|
// Compare backends
|
|
if !reflect.DeepEqual(actualConfig.Backends, c.expectedBackends) {
|
|
t.Fatalf("expected %#v, got %#v", c.expectedBackends, actualConfig.Backends)
|
|
}
|
|
if !reflect.DeepEqual(actualConfig.Frontends, c.expectedFrontends) {
|
|
t.Fatalf("expected %#v, got %#v", c.expectedFrontends, actualConfig.Frontends)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwarmTaskParsing(t *testing.T) {
|
|
cases := []struct {
|
|
service swarm.Service
|
|
tasks []swarm.Task
|
|
isGlobalSvc bool
|
|
expectedNames map[string]string
|
|
networks map[string]*docker.NetworkResource
|
|
}{
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
},
|
|
},
|
|
},
|
|
tasks: []swarm.Task{
|
|
{
|
|
ID: "id1",
|
|
Slot: 1,
|
|
},
|
|
{
|
|
ID: "id2",
|
|
Slot: 2,
|
|
},
|
|
{
|
|
ID: "id3",
|
|
Slot: 3,
|
|
},
|
|
},
|
|
isGlobalSvc: false,
|
|
expectedNames: map[string]string{
|
|
"id1": "container.1",
|
|
"id2": "container.2",
|
|
"id3": "container.3",
|
|
},
|
|
networks: map[string]*docker.NetworkResource{
|
|
"1": {
|
|
Name: "foo",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
service: swarm.Service{
|
|
Spec: swarm.ServiceSpec{
|
|
Annotations: swarm.Annotations{
|
|
Name: "container",
|
|
},
|
|
},
|
|
},
|
|
tasks: []swarm.Task{
|
|
{
|
|
ID: "id1",
|
|
},
|
|
{
|
|
ID: "id2",
|
|
},
|
|
{
|
|
ID: "id3",
|
|
},
|
|
},
|
|
isGlobalSvc: true,
|
|
expectedNames: map[string]string{
|
|
"id1": "container.id1",
|
|
"id2": "container.id2",
|
|
"id3": "container.id3",
|
|
},
|
|
networks: map[string]*docker.NetworkResource{
|
|
"1": {
|
|
Name: "foo",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, e := range cases {
|
|
dockerData := parseService(e.service, e.networks)
|
|
|
|
for _, task := range e.tasks {
|
|
taskDockerData := parseTasks(task, dockerData, map[string]*docker.NetworkResource{}, e.isGlobalSvc)
|
|
if !reflect.DeepEqual(taskDockerData.Name, e.expectedNames[task.ID]) {
|
|
t.Fatalf("expect %v, got %v", e.expectedNames[task.ID], taskDockerData.Name)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetServiceProtocol(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "http",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "another",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.protocol": "https",
|
|
},
|
|
},
|
|
},
|
|
expected: "https",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.myservice.protocol": "https",
|
|
},
|
|
},
|
|
},
|
|
expected: "https",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getServiceProtocol(dockerData, "myservice")
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetServiceWeight(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "0",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "another",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.weight": "200",
|
|
},
|
|
},
|
|
},
|
|
expected: "200",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.myservice.weight": "31337",
|
|
},
|
|
},
|
|
},
|
|
expected: "31337",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getServiceWeight(dockerData, "myservice")
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetServicePort(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "another",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.port": "2500",
|
|
},
|
|
},
|
|
},
|
|
expected: "2500",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.myservice.port": "1234",
|
|
},
|
|
},
|
|
},
|
|
expected: "1234",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getServicePort(dockerData, "myservice")
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetServiceFrontendRule(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "Host:foo.",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "another",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.rule": "Path:/helloworld",
|
|
},
|
|
},
|
|
},
|
|
expected: "Path:/helloworld",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.myservice.frontend.rule": "Path:/mycustomservicepath",
|
|
},
|
|
},
|
|
},
|
|
expected: "Path:/mycustomservicepath",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getServiceFrontendRule(dockerData, "myservice")
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetServiceBackend(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "foo-myservice",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "another",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.backend": "another-backend",
|
|
},
|
|
},
|
|
},
|
|
expected: "another-backend-myservice",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.myservice.frontend.backend": "custom-backend",
|
|
},
|
|
},
|
|
},
|
|
expected: "custom-backend",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getServiceBackend(dockerData, "myservice")
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetServicePriority(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "0",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "another",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.priority": "33",
|
|
},
|
|
},
|
|
},
|
|
expected: "33",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.myservice.frontend.priority": "2503",
|
|
},
|
|
},
|
|
},
|
|
expected: "2503",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getServicePriority(dockerData, "myservice")
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetServicePassHostHeader(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: "true",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "another",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.passHostHeader": "false",
|
|
},
|
|
},
|
|
},
|
|
expected: "false",
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.myservice.frontend.passHostHeader": "false",
|
|
},
|
|
},
|
|
},
|
|
expected: "false",
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getServicePassHostHeader(dockerData, "myservice")
|
|
if actual != e.expected {
|
|
t.Fatalf("expected %q, got %q", e.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerGetServiceEntryPoints(t *testing.T) {
|
|
provider := &Docker{}
|
|
|
|
containers := []struct {
|
|
container docker.ContainerJSON
|
|
expected []string
|
|
}{
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{},
|
|
},
|
|
expected: []string{},
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "another",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.frontend.entryPoints": "http,https",
|
|
},
|
|
},
|
|
},
|
|
expected: []string{"http", "https"},
|
|
},
|
|
{
|
|
container: docker.ContainerJSON{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.myservice.frontend.entryPoints": "http,https",
|
|
},
|
|
},
|
|
},
|
|
expected: []string{"http", "https"},
|
|
},
|
|
}
|
|
|
|
for _, e := range containers {
|
|
dockerData := parseContainer(e.container)
|
|
actual := provider.getServiceEntryPoints(dockerData, "myservice")
|
|
if !reflect.DeepEqual(actual, e.expected) {
|
|
t.Fatalf("expected %q, got %q for container %q", e.expected, actual, dockerData.Name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDockerLoadDockerServiceConfig(t *testing.T) {
|
|
cases := []struct {
|
|
containers []docker.ContainerJSON
|
|
expectedFrontends map[string]*types.Frontend
|
|
expectedBackends map[string]*types.Backend
|
|
}{
|
|
{
|
|
containers: []docker.ContainerJSON{},
|
|
expectedFrontends: map[string]*types.Frontend{},
|
|
expectedBackends: map[string]*types.Backend{},
|
|
},
|
|
{
|
|
containers: []docker.ContainerJSON{
|
|
{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "foo",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.service.port": "2503",
|
|
"traefik.service.frontend.entryPoints": "http,https",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"bridge": {
|
|
IPAddress: "127.0.0.1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedFrontends: map[string]*types.Frontend{
|
|
"frontend-foo-service": {
|
|
Backend: "backend-foo-service",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{"http", "https"},
|
|
Routes: map[string]types.Route{
|
|
"service-service": {
|
|
Rule: "Host:foo.docker.localhost",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedBackends: map[string]*types.Backend{
|
|
"backend-foo-service": {
|
|
Servers: map[string]types.Server{
|
|
"service": {
|
|
URL: "http://127.0.0.1:2503",
|
|
Weight: 0,
|
|
},
|
|
},
|
|
CircuitBreaker: nil,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
containers: []docker.ContainerJSON{
|
|
{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test1",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.service.port": "2503",
|
|
"traefik.service.protocol": "https",
|
|
"traefik.service.weight": "80",
|
|
"traefik.service.frontend.backend": "foobar",
|
|
"traefik.service.frontend.passHostHeader": "false",
|
|
"traefik.service.frontend.rule": "Path:/mypath",
|
|
"traefik.service.frontend.priority": "5000",
|
|
"traefik.service.frontend.entryPoints": "http,https,ws",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"bridge": {
|
|
IPAddress: "127.0.0.1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
ContainerJSONBase: &docker.ContainerJSONBase{
|
|
Name: "test2",
|
|
},
|
|
Config: &container.Config{
|
|
Labels: map[string]string{
|
|
"traefik.anotherservice.port": "8079",
|
|
"traefik.anotherservice.weight": "33",
|
|
"traefik.anotherservice.frontend.rule": "Path:/anotherpath",
|
|
},
|
|
},
|
|
NetworkSettings: &docker.NetworkSettings{
|
|
NetworkSettingsBase: docker.NetworkSettingsBase{
|
|
Ports: nat.PortMap{
|
|
"80/tcp": {},
|
|
},
|
|
},
|
|
Networks: map[string]*network.EndpointSettings{
|
|
"bridge": {
|
|
IPAddress: "127.0.0.1",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedFrontends: map[string]*types.Frontend{
|
|
"frontend-foobar": {
|
|
Backend: "backend-foobar",
|
|
PassHostHeader: false,
|
|
Priority: 5000,
|
|
EntryPoints: []string{"http", "https", "ws"},
|
|
Routes: map[string]types.Route{
|
|
"service-service": {
|
|
Rule: "Path:/mypath",
|
|
},
|
|
},
|
|
},
|
|
"frontend-test2-anotherservice": {
|
|
Backend: "backend-test2-anotherservice",
|
|
PassHostHeader: true,
|
|
EntryPoints: []string{},
|
|
Routes: map[string]types.Route{
|
|
"service-anotherservice": {
|
|
Rule: "Path:/anotherpath",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedBackends: map[string]*types.Backend{
|
|
"backend-foobar": {
|
|
Servers: map[string]types.Server{
|
|
"service": {
|
|
URL: "https://127.0.0.1:2503",
|
|
Weight: 80,
|
|
},
|
|
},
|
|
CircuitBreaker: nil,
|
|
},
|
|
"backend-test2-anotherservice": {
|
|
Servers: map[string]types.Server{
|
|
"service": {
|
|
URL: "http://127.0.0.1:8079",
|
|
Weight: 33,
|
|
},
|
|
},
|
|
CircuitBreaker: nil,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
provider := &Docker{
|
|
Domain: "docker.localhost",
|
|
ExposedByDefault: true,
|
|
}
|
|
|
|
for _, c := range cases {
|
|
var dockerDataList []dockerData
|
|
for _, container := range c.containers {
|
|
dockerData := parseContainer(container)
|
|
dockerDataList = append(dockerDataList, dockerData)
|
|
}
|
|
|
|
actualConfig := provider.loadDockerConfig(dockerDataList)
|
|
// Compare backends
|
|
if !reflect.DeepEqual(actualConfig.Backends, c.expectedBackends) {
|
|
t.Fatalf("expected %#v, got %#v", c.expectedBackends, actualConfig.Backends)
|
|
}
|
|
if !reflect.DeepEqual(actualConfig.Frontends, c.expectedFrontends) {
|
|
t.Fatalf("expected %#v, got %#v", c.expectedFrontends, actualConfig.Frontends)
|
|
}
|
|
}
|
|
}
|