func (s *HandlersSuite) TestListNodeHandlerWithoutCluster(c *gocheck.C) {
var result []map[string]string
p1 := Pool{Name: "pool1", Nodes: []string{"host.com:4243"}}
p2 := Pool{Name: "pool2", Nodes: []string{"host.com:4243"}}
err := s.conn.Collection(schedulerCollection).Insert(p1, p2)
c.Assert(err, gocheck.IsNil)
defer s.conn.Collection(schedulerCollection).RemoveId(p1.Name)
defer s.conn.Collection(schedulerCollection).RemoveId(p2.Name)
config.Set("docker:segregate", true)
defer config.Unset("docker:segregate")
config.Set("docker:scheduler:redis-server", "127.0.0.1:6379")
defer config.Unset("docker:scheduler:redis-server")
dCluster = nil
req, err := http.NewRequest("GET", "/node/", nil)
rec := httptest.NewRecorder()
err = listNodeHandler(rec, req, nil)
c.Assert(err, gocheck.IsNil)
body, err := ioutil.ReadAll(rec.Body)
c.Assert(err, gocheck.IsNil)
err = json.Unmarshal(body, &result)
c.Assert(err, gocheck.IsNil)
c.Assert(result[0]["ID"], gocheck.DeepEquals, "host.com:4243")
c.Assert(result[0]["Address"], gocheck.DeepEquals, "host.com:4243")
c.Assert(result[1]["ID"], gocheck.DeepEquals, "host.com:4243")
c.Assert(result[1]["Address"], gocheck.DeepEquals, "host.com:4243")
}
func (s *S) TestAddBackendWithVpc(c *gocheck.C) {
old, _ := config.Get("juju:elb-avail-zones")
config.Unset("juju:elb-avail-zones")
config.Set("juju:elb-use-vpc", true)
config.Set("juju:elb-vpc-subnets", []string{"subnet-a4a3a2a1", "subnet-002200"})
config.Set("juju:elb-vpc-secgroups", []string{"sg-0900"})
defer func() {
config.Set("juju:elb-avail-zones", old)
config.Unset("juju:elb-use-vpc")
config.Unset("juju:elb-vpc-subnets")
config.Unset("juju:elb-vpc-secgroups")
}()
router := elbRouter{}
err := router.AddBackend("tip")
c.Assert(err, gocheck.IsNil)
defer router.RemoveBackend("tip")
resp, err := s.client.DescribeLoadBalancers("tip")
c.Assert(err, gocheck.IsNil)
c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1)
lbd := resp.LoadBalancerDescriptions[0]
c.Assert(lbd.Subnets, gocheck.DeepEquals, []string{"subnet-a4a3a2a1", "subnet-002200"})
c.Assert(lbd.SecurityGroups, gocheck.DeepEquals, []string{"sg-0900"})
c.Assert(lbd.Scheme, gocheck.Equals, "internal")
c.Assert(lbd.AvailZones, gocheck.HasLen, 0)
}
func (s *HandlersSuite) TestAutoScaleRunHandler(c *check.C) {
mainDockerProvisioner.cluster, _ = cluster.New(&segregatedScheduler{}, &cluster.MapStorage{},
cluster.Node{Address: "localhost:1999", Metadata: map[string]string{
"pool": "pool1",
}},
)
config.Set("docker:auto-scale:enabled", true)
defer config.Unset("docker:auto-scale:enabled")
config.Set("docker:auto-scale:max-container-count", 2)
defer config.Unset("docker:auto-scale:max-container-count")
recorder := httptest.NewRecorder()
request, err := http.NewRequest("POST", "/docker/autoscale/run", nil)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
server := api.RunServer(true)
server.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusOK)
c.Assert(recorder.Header().Get("Content-Type"), check.Equals, "application/x-json-stream")
body := recorder.Body.String()
parts := strings.Split(body, "\n")
c.Assert(parts, check.DeepEquals, []string{
`{"Message":"running scaler *docker.countScaler for \"pool\": \"pool1\"\n"}`,
`{"Message":"nothing to do for \"pool\": \"pool1\"\n"}`,
``,
})
c.Assert(eventtest.EventDesc{
Target: event.Target{Type: event.TargetTypePool},
Owner: s.token.GetUserName(),
Kind: "node.autoscale.update.run",
}, eventtest.HasEvent)
}
func (s *S) TestRegisterAndGet(c *check.C) {
var r Router
var prefixes []string
var names []string
routerCreator := func(name, prefix string) (Router, error) {
names = append(names, name)
prefixes = append(prefixes, prefix)
return r, nil
}
Register("router", routerCreator)
config.Set("routers:mine:type", "router")
defer config.Unset("routers:mine:type")
got, err := Get("mine")
c.Assert(err, check.IsNil)
c.Assert(r, check.DeepEquals, got)
c.Assert(names, check.DeepEquals, []string{"mine"})
c.Assert(prefixes, check.DeepEquals, []string{"routers:mine"})
_, err = Get("unknown-router")
c.Assert(err, check.Not(check.IsNil))
c.Assert("config key 'routers:unknown-router:type' not found", check.Equals, err.Error())
config.Set("routers:mine-unknown:type", "unknown")
defer config.Unset("routers:mine-unknown:type")
_, err = Get("mine-unknown")
c.Assert(err, check.Not(check.IsNil))
c.Assert(`unknown router: "unknown".`, check.Equals, err.Error())
}
func (s *HandlersSuite) TestAutoScaleListRulesWithDBConfig(c *check.C) {
config.Set("docker:auto-scale:scale-down-ratio", 2.0)
defer config.Unset("docker:auto-scale:max-container-count")
config.Set("docker:scheduler:total-memory-metadata", "maxmemory")
defer config.Unset("docker:scheduler:total-memory-metadata")
rules := []autoScaleRule{
{MetadataFilter: "", Enabled: true, MaxContainerCount: 10, ScaleDownRatio: 1.2},
{MetadataFilter: "pool1", Enabled: true, ScaleDownRatio: 1.1, MaxMemoryRatio: 2.0},
}
for _, r := range rules {
err := r.update()
c.Assert(err, check.IsNil)
}
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/docker/autoscale/rules", nil)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
server := api.RunServer(true)
server.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusOK)
var reqRules []autoScaleRule
err = json.Unmarshal(recorder.Body.Bytes(), &reqRules)
c.Assert(err, check.IsNil)
c.Assert(reqRules, check.DeepEquals, rules)
}
func (s *HandlersSuite) TestAutoScaleListRulesWithLegacyConfig(c *check.C) {
config.Set("docker:auto-scale:metadata-filter", "mypool")
config.Set("docker:auto-scale:max-container-count", 4)
config.Set("docker:auto-scale:scale-down-ratio", 1.5)
config.Set("docker:auto-scale:prevent-rebalance", true)
config.Set("docker:scheduler:max-used-memory", 0.9)
defer config.Unset("docker:auto-scale:metadata-filter")
defer config.Unset("docker:auto-scale:max-container-count")
defer config.Unset("docker:auto-scale:scale-down-ratio")
defer config.Unset("docker:auto-scale:prevent-rebalance")
defer config.Unset("docker:scheduler:max-used-memory")
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/docker/autoscale/rules", nil)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
server := api.RunServer(true)
server.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusOK)
var rules []autoScaleRule
err = json.Unmarshal(recorder.Body.Bytes(), &rules)
c.Assert(err, check.IsNil)
c.Assert(rules, check.DeepEquals, []autoScaleRule{
{MetadataFilter: "mypool", Enabled: true, MaxContainerCount: 4, ScaleDownRatio: 1.5, PreventRebalance: true, MaxMemoryRatio: 0.9},
})
}
func (s *HandlersSuite) TestListNodeHandlerWithoutCluster(c *gocheck.C) {
var result []node
config.Set("docker:segregate", true)
defer config.Unset("docker:segregate")
config.Set("docker:scheduler:redis-server", "127.0.0.1:6379")
defer config.Unset("docker:scheduler:redis-server")
dCluster = nil
err := s.conn.Collection(schedulerCollection).Insert(node{Address: "host.com:4243", ID: "server01"})
c.Assert(err, gocheck.IsNil)
defer s.conn.Collection(schedulerCollection).RemoveId("server01")
err = s.conn.Collection(schedulerCollection).Insert(node{Address: "host.com:4243", ID: "server02"})
c.Assert(err, gocheck.IsNil)
defer s.conn.Collection(schedulerCollection).RemoveId("server02")
req, err := http.NewRequest("GET", "/node/", nil)
rec := httptest.NewRecorder()
err = listNodeHandler(rec, req, nil)
c.Assert(err, gocheck.IsNil)
body, err := ioutil.ReadAll(rec.Body)
c.Assert(err, gocheck.IsNil)
err = json.Unmarshal(body, &result)
c.Assert(err, gocheck.IsNil)
c.Assert(result[0].ID, gocheck.Equals, "server01")
c.Assert(result[0].Address, gocheck.DeepEquals, "host.com:4243")
c.Assert(result[1].ID, gocheck.Equals, "server02")
c.Assert(result[1].Address, gocheck.DeepEquals, "host.com:4243")
}
func (s *HandlersSuite) TestAutoScaleRunHandler(c *check.C) {
mainDockerProvisioner.cluster, _ = cluster.New(&segregatedScheduler{}, &cluster.MapStorage{},
cluster.Node{Address: "localhost:1999", Metadata: map[string]string{
"pool": "pool1",
}},
)
config.Set("docker:auto-scale:group-by-metadata", "pool")
config.Set("docker:auto-scale:max-container-count", 2)
defer config.Unset("docker:auto-scale:max-container-count")
defer config.Unset("docker:auto-scale:group-by-metadata")
recorder := httptest.NewRecorder()
request, err := http.NewRequest("POST", "/docker/autoscale/run", nil)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
server := api.RunServer(true)
server.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusOK)
body := recorder.Body.String()
parts := strings.Split(body, "\n")
c.Assert(parts, check.DeepEquals, []string{
`{"Message":"[node autoscale] running scaler *docker.countScaler for \"pool\": \"pool1\"\n"}`,
`{"Message":"[node autoscale] nothing to do for \"pool\": \"pool1\"\n"}`,
``,
})
}
func (s *S) TestDockerCluster(c *gocheck.C) {
config.Set("docker:servers", []string{"http://localhost:4243", "http://10.10.10.10:4243"})
defer config.Unset("docker:servers")
nodes, err := dCluster.Nodes()
c.Assert(err, gocheck.IsNil)
cmutex.Lock()
dCluster = nil
cmutex.Unlock()
defer func() {
cmutex.Lock()
defer cmutex.Unlock()
dCluster, err = cluster.New(nil, &cluster.MapStorage{}, nodes...)
c.Assert(err, gocheck.IsNil)
}()
config.Set("docker:cluster:redis-server", "127.0.0.1:6379")
defer config.Unset("docker:cluster:redis-server")
clus := dockerCluster()
c.Assert(clus, gocheck.NotNil)
currentNodes, err := clus.Nodes()
c.Assert(err, gocheck.IsNil)
sortedNodes := NodeList(currentNodes)
sort.Sort(sortedNodes)
c.Assert(sortedNodes, gocheck.DeepEquals, NodeList([]cluster.Node{
{Address: "http://10.10.10.10:4243", Metadata: map[string]string{}},
{Address: "http://localhost:4243", Metadata: map[string]string{}},
}))
}
func (s *S) TestHealerHealNodeWaitAndRegisterError(c *check.C) {
iaas.RegisterIaasProvider("my-healer-iaas", iaasTesting.NewHealerIaaSConstructor("addr1", nil))
_, err := iaas.CreateMachineForIaaS("my-healer-iaas", map[string]string{})
c.Assert(err, check.IsNil)
iaas.RegisterIaasProvider("my-healer-iaas", iaasTesting.NewHealerIaaSConstructor("addr2", nil))
config.Set("iaas:node-protocol", "http")
config.Set("iaas:node-port", 2)
defer config.Unset("iaas:node-protocol")
defer config.Unset("iaas:node-port")
p := provisiontest.ProvisionerInstance
err = p.AddNode(provision.AddNodeOptions{
Address: "http://addr1:1",
Metadata: map[string]string{"iaas": "my-healer-iaas"},
})
c.Assert(err, check.IsNil)
p.PrepareFailure("AddNode", fmt.Errorf("add node error"))
healer := newNodeHealer(nodeHealerArgs{
WaitTimeNewMachine: time.Second,
})
healer.Shutdown()
nodes, err := p.ListNodes(nil)
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Address(), check.Equals, "http://addr1:1")
created, err := healer.healNode(nodes[0])
c.Assert(err, check.ErrorMatches, ".*error registering new node: add node error.*")
c.Assert(created, check.IsNil)
nodes, err = p.ListNodes(nil)
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Address(), check.Equals, "http://addr1:1")
c.Assert(nodes[0].Status(), check.Equals, "enabled")
}
func (s *S) TestInitializeBS(c *check.C) {
config.Set("host", "127.0.0.1:8080")
config.Set("docker:bs:image", "tsuru/bs:v10")
defer config.Unset("host")
defer config.Unset("docker:bs:image")
initialized, err := InitializeBS()
c.Assert(err, check.IsNil)
c.Assert(initialized, check.Equals, true)
nodeContainer, err := LoadNodeContainer("", BsDefaultName)
c.Assert(err, check.IsNil)
c.Assert(nodeContainer.Config.Env[0], check.Matches, `^TSURU_TOKEN=.{40}$`)
nodeContainer.Config.Env = nodeContainer.Config.Env[1:]
c.Assert(nodeContainer, check.DeepEquals, &NodeContainerConfig{
Name: BsDefaultName,
Config: docker.Config{
Image: "tsuru/bs:v10",
Env: []string{
"TSURU_ENDPOINT=http://127.0.0.1:8080/",
"HOST_PROC=/prochost",
"SYSLOG_LISTEN_ADDRESS=udp://0.0.0.0:1514",
},
},
HostConfig: docker.HostConfig{
RestartPolicy: docker.AlwaysRestart(),
Privileged: true,
NetworkMode: "host",
Binds: []string{"/proc:/prochost:ro"},
},
})
initialized, err = InitializeBS()
c.Assert(err, check.IsNil)
c.Assert(initialized, check.Equals, false)
}
func (s *S) TearDownSuite(c *C) {
storage, err := Conn()
c.Assert(err, IsNil)
defer storage.Close()
config.Unset("database:url")
config.Unset("database:name")
s.etcd.Close()
}
func (s *S) TearDownSuite(c *check.C) {
strg, err := Conn()
c.Assert(err, check.IsNil)
defer strg.Close()
config.Unset("database:url")
config.Unset("database:name")
strg.Collection("apps").Database.DropDatabase()
}
func (s *S) TestCreateBsContainerSocketAndCustomSysLogPort(c *check.C) {
server, err := testing.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
defer server.Stop()
server.CustomHandler("/images/create", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
server.DefaultHandler().ServeHTTP(w, r)
w.Write([]byte(pullOutputNoDigest))
}))
config.Set("host", "127.0.0.1:8080")
config.Set("docker:bs:image", "myregistry/tsuru/bs")
config.Set("docker:bs:socket", "/tmp/docker.sock")
defer config.Unset("docker:bs:socket")
config.Set("docker:bs:syslog-port", 1519)
defer config.Unset("docker:bs:syslog-port")
conf, err := LoadConfig(nil)
c.Assert(err, check.IsNil)
conf.Add("VAR1", "VALUE1")
conf.Add("VAR2", "VALUE2")
conf.Add("TSURU_ENDPOINT", "ignored")
conf.AddPool("pool1", "VAR2", "VALUE_FOR_POOL1")
conf.AddPool("pool2", "VAR2", "VALUE_FOR_POOL2")
conf.AddPool("pool1", "SYSLOG_LISTEN_ADDRESS", "alsoignored")
err = conf.SaveEnvs()
c.Assert(err, check.IsNil)
p, err := dockertest.NewFakeDockerProvisioner()
c.Assert(err, check.IsNil)
defer p.Destroy()
err = createContainer(server.URL(), "pool1", p, true)
c.Assert(err, check.IsNil)
client, err := docker.NewClient(server.URL())
c.Assert(err, check.IsNil)
containers, err := client.ListContainers(docker.ListContainersOptions{All: true})
c.Assert(err, check.IsNil)
c.Assert(containers, check.HasLen, 1)
container, err := client.InspectContainer(containers[0].ID)
c.Assert(err, check.IsNil)
c.Assert(container.Name, check.Equals, "big-sibling")
c.Assert(container.HostConfig.Binds, check.DeepEquals, []string{"/tmp/docker.sock:/var/run/docker.sock:rw"})
c.Assert(container.Config.Image, check.Equals, "myregistry/tsuru/bs")
c.Assert(container.State.Running, check.Equals, true)
conf, err = LoadConfig(nil)
c.Assert(err, check.IsNil)
token, _ := getToken(conf)
expectedEnv := []string{
"DOCKER_ENDPOINT=unix:///var/run/docker.sock",
"TSURU_ENDPOINT=http://127.0.0.1:8080/",
"TSURU_TOKEN=" + token,
"SYSLOG_LISTEN_ADDRESS=udp://0.0.0.0:1519",
"VAR1=VALUE1",
"VAR2=VALUE_FOR_POOL1",
}
sort.Strings(expectedEnv)
sort.Strings(container.Config.Env)
c.Assert(container.Config.Env, check.DeepEquals, expectedEnv)
c.Assert(conf.GetExtraString("image"), check.Equals, "myregistry/tsuru/bs")
}
func (s *S) TestHealerHandleErrorThrottled(c *check.C) {
factory, iaasInst := iaasTesting.NewHealerIaaSConstructorWithInst("addr1")
iaas.RegisterIaasProvider("my-healer-iaas", factory)
_, err := iaas.CreateMachineForIaaS("my-healer-iaas", map[string]string{})
c.Assert(err, check.IsNil)
iaasInst.Addr = "addr2"
config.Set("iaas:node-protocol", "http")
config.Set("iaas:node-port", 2)
defer config.Unset("iaas:node-protocol")
defer config.Unset("iaas:node-port")
p := provisiontest.ProvisionerInstance
err = p.AddNode(provision.AddNodeOptions{
Address: "http://addr1:1",
Metadata: map[string]string{"iaas": "my-healer-iaas"},
})
c.Assert(err, check.IsNil)
node, err := p.GetNode("http://addr1:1")
c.Assert(err, check.IsNil)
healer := newNodeHealer(nodeHealerArgs{
FailuresBeforeHealing: 1,
WaitTimeNewMachine: time.Minute,
})
healer.Shutdown()
healer.started = time.Now().Add(-3 * time.Second)
conf := healerConfig()
err = conf.SaveBase(NodeHealerConfig{Enabled: boolPtr(true), MaxUnresponsiveTime: intPtr(1)})
c.Assert(err, check.IsNil)
err = healer.UpdateNodeData(node, []provision.NodeCheckResult{})
c.Assert(err, check.IsNil)
time.Sleep(1200 * time.Millisecond)
nodes, err := p.ListNodes(nil)
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Address(), check.Equals, "http://addr1:1")
machines, err := iaas.ListMachines()
c.Assert(err, check.IsNil)
c.Assert(machines, check.HasLen, 1)
c.Assert(machines[0].Address, check.Equals, "addr1")
for i := 0; i < 3; i++ {
var evt *event.Event
evt, err = event.NewInternal(&event.Opts{
Target: event.Target{Type: "node", Value: nodes[0].Address()},
InternalKind: "healer",
Allowed: event.Allowed(permission.PermPoolReadEvents),
})
c.Assert(err, check.IsNil)
err = evt.Done(nil)
c.Assert(err, check.IsNil)
}
err = healer.tryHealingNode(nodes[0], "myreason", nil)
c.Assert(err, check.ErrorMatches, "Error trying to insert node healing event, healing aborted: event throttled, limit for healer on node \".*?\" is 3 every 5m0s")
nodes, err = p.ListNodes(nil)
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Address(), check.Equals, "http://addr1:1")
}
func (s *S) TestHealerHealNodeWaitAndRegisterError(c *check.C) {
defer func() {
machines, _ := iaas.ListMachines()
for _, m := range machines {
m.Destroy()
}
}()
iaas.RegisterIaasProvider("my-healer-iaas", newHealerIaaSConstructor("127.0.0.1", nil))
_, err := iaas.CreateMachineForIaaS("my-healer-iaas", map[string]string{})
c.Assert(err, check.IsNil)
iaas.RegisterIaasProvider("my-healer-iaas", newHealerIaaSConstructor("localhost", nil))
node1, err := testing.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
node2, err := testing.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
node2.PrepareFailure("ping-failure", "/_ping")
config.Set("iaas:node-protocol", "http")
config.Set("iaas:node-port", urlPort(node2.URL()))
defer config.Unset("iaas:node-protocol")
defer config.Unset("iaas:node-port")
cluster, err := cluster.New(nil, &cluster.MapStorage{},
cluster.Node{Address: node1.URL()},
)
c.Assert(err, check.IsNil)
node1.PrepareFailure("pingErr", "/_ping")
cluster.StartActiveMonitoring(100 * time.Millisecond)
time.Sleep(300 * time.Millisecond)
cluster.StopActiveMonitoring()
var p dockerProvisioner
err = p.Initialize()
c.Assert(err, check.IsNil)
p.cluster = cluster
healer := nodeHealer{
locks: make(map[string]*sync.Mutex),
provisioner: &p,
disabledTime: 0,
failuresBeforeHealing: 1,
waitTimeNewMachine: 1 * time.Second,
}
nodes, err := p.getCluster().UnfilteredNodes()
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(urlPort(nodes[0].Address), check.Equals, urlPort(node1.URL()))
c.Assert(urlToHost(nodes[0].Address), check.Equals, "127.0.0.1")
c.Assert(nodes[0].FailureCount() > 0, check.Equals, true)
nodes[0].Metadata["iaas"] = "my-healer-iaas"
created, err := healer.healNode(&nodes[0])
c.Assert(err, check.ErrorMatches, ".*error registering new node.*")
c.Assert(created.Address, check.Equals, "")
c.Assert(nodes[0].FailureCount(), check.Equals, 0)
nodes, err = p.getCluster().UnfilteredNodes()
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(urlPort(nodes[0].Address), check.Equals, urlPort(node1.URL()))
c.Assert(urlToHost(nodes[0].Address), check.Equals, "127.0.0.1")
}
func (s *S) TestReadOnlyURLWithSSHAndPort(c *gocheck.C) {
config.Set("git:ssh:use", true)
defer config.Unset("git:ssh:use")
config.Set("git:ssh:port", "49022")
defer config.Unset("git:ssh:port")
host, err := config.GetString("host")
c.Assert(err, gocheck.IsNil)
remote := (&Repository{Name: "lol"}).ReadOnlyURL()
c.Assert(remote, gocheck.Equals, fmt.Sprintf("ssh://git@%s:49022/lol.git", host))
}
func (s *S) TestCreateBsContainerSocketAndCustomSysLogPort(c *check.C) {
server, err := testing.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
defer server.Stop()
server.CustomHandler("/images/create", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
server.DefaultHandler().ServeHTTP(w, r)
w.Write([]byte(pullOutputNoDigest))
}))
config.Set("host", "127.0.0.1:8080")
config.Set("docker:bs:image", "myregistry/tsuru/bs")
config.Set("docker:bs:reporter-interval", 60)
defer config.Unset("docker:bs:reporter-interval")
config.Set("docker:bs:socket", "/tmp/docker.sock")
defer config.Unset("docker:bs:socket")
config.Set("docker:bs:syslog-port", 1519)
defer config.Unset("docker:bs:syslog-port")
config.Set("docker:bs:syslog-forward-addresses", []interface{}{"udp://host1:518", "udp://host2:518", "tcp://host3:518"})
defer config.Unset("docker:bs:syslog-forward-addresses")
var task runBs
err = task.createBsContainer(server.URL())
c.Assert(err, check.IsNil)
client, err := docker.NewClient(server.URL())
c.Assert(err, check.IsNil)
containers, err := client.ListContainers(docker.ListContainersOptions{All: true})
c.Assert(err, check.IsNil)
c.Assert(containers, check.HasLen, 1)
container, err := client.InspectContainer(containers[0].ID)
c.Assert(err, check.IsNil)
c.Assert(container.Name, check.Equals, "big-sibling")
c.Assert(container.HostConfig.Binds, check.DeepEquals, []string{"/tmp/docker.sock:/var/run/docker.sock:rw"})
expectedBinding := []docker.PortBinding{{HostIP: "0.0.0.0", HostPort: "1519"}}
c.Assert(container.HostConfig.PortBindings[docker.Port("514/udp")], check.DeepEquals, expectedBinding)
_, ok := container.Config.ExposedPorts[docker.Port("1519/udp")]
c.Assert(ok, check.Equals, true)
c.Assert(container.Config.Image, check.Equals, "myregistry/tsuru/bs")
c.Assert(container.State.Running, check.Equals, true)
expectedEnv := map[string]string{
"DOCKER_ENDPOINT": "unix:///var/run/docker.sock",
"TSURU_ENDPOINT": "http://127.0.0.1:8080/",
"TSURU_TOKEN": "abc123",
"STATUS_INTERVAL": "60",
"SYSLOG_LISTEN_ADDRESS": "udp://0.0.0.0:514",
"SYSLOG_FORWARD_ADDRESSES": "udp://host1:518,udp://host2:518,tcp://host3:518",
}
gotEnv := parseEnvs(container.Config.Env)
_, ok = gotEnv["TSURU_TOKEN"]
c.Assert(ok, check.Equals, true)
gotEnv["TSURU_TOKEN"] = expectedEnv["TSURU_TOKEN"]
c.Assert(gotEnv, check.DeepEquals, expectedEnv)
conf, err := loadBsConfig()
c.Assert(err, check.IsNil)
c.Assert(conf.Image, check.Equals, "myregistry/tsuru/bs")
}
func (s *S) TestBuildClusterStorage(c *check.C) {
defer config.Set("docker:cluster:mongo-url", "127.0.0.1:27017")
defer config.Set("docker:cluster:mongo-database", "docker_provision_tests_cluster_stor")
config.Unset("docker:cluster:mongo-url")
_, err := buildClusterStorage()
c.Assert(err, check.ErrorMatches, ".*docker:cluster:{mongo-url,mongo-database} must be set.")
config.Set("docker:cluster:mongo-url", "127.0.0.1:27017")
config.Unset("docker:cluster:mongo-database")
_, err = buildClusterStorage()
c.Assert(err, check.ErrorMatches, ".*docker:cluster:{mongo-url,mongo-database} must be set.")
config.Set("docker:cluster:storage", "xxxx")
}
func (s *S) TestCreateMachineIaaSFailsWithNoDriver(c *check.C) {
config.Unset("iaas:dockermachine:driver")
config.Set("iaas:dockermachine:ca-path", "/etc/ca-path")
defer config.Unset("iaas:dockermachine:ca-path")
i := newDockerMachineIaaS("dockermachine")
dmIaas := i.(*dockerMachineIaaS)
dmIaas.apiFactory = NewFakeDockerMachine
m, err := dmIaas.CreateMachine(map[string]string{
"name": "host-name",
})
c.Assert(err, check.Equals, errDriverNotSet)
c.Assert(m, check.IsNil)
}
func (s *S) TestConnectDefaultSettings(c *gocheck.C) {
oldURL, _ := config.Get("database:url")
defer config.Set("database:url", oldURL)
oldName, _ := config.Get("database:name")
defer config.Set("database:name", oldName)
config.Unset("database:url")
config.Unset("database:name")
conn, err := Conn()
c.Assert(err, gocheck.IsNil)
defer conn.Close()
c.Assert(conn.User().Database.Name, gocheck.Equals, "gandalf")
c.Assert(conn.User().Database.Session.LiveServers(), gocheck.DeepEquals, []string{"127.0.0.1:27017"})
}
func (s *S) TestELBSupport(c *gocheck.C) {
defer config.Unset("juju:use-elb")
config.Set("juju:use-elb", true)
p := JujuProvisioner{}
c.Assert(p.elbSupport(), gocheck.Equals, true)
config.Set("juju:use-elb", false)
c.Assert(p.elbSupport(), gocheck.Equals, true) // Read config only once.
p = JujuProvisioner{}
c.Assert(p.elbSupport(), gocheck.Equals, false)
config.Unset("juju:use-elb")
p = JujuProvisioner{}
c.Assert(p.elbSupport(), gocheck.Equals, false)
}
func (s *S) TestRoutersListNonAdmin(c *check.C) {
config.Set("routers:router1:type", "foo")
config.Set("routers:router2:type", "bar")
defer config.Unset("routers:router1:type")
defer config.Unset("routers:router2:type")
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/plans/routers", nil)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
m := RunServer(true)
m.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusForbidden)
}
func (s *S) TestReadWriteURLWithSSHAndPort(c *gocheck.C) {
config.Set("git:ssh:use", true)
defer config.Unset("git:ssh:use")
config.Set("git:ssh:port", "49022")
defer config.Unset("git:ssh:port")
uid, err := config.GetString("uid")
c.Assert(err, gocheck.IsNil)
host, err := config.GetString("host")
c.Assert(err, gocheck.IsNil)
remote := (&Repository{Name: "lol"}).ReadWriteURL()
expected := fmt.Sprintf("ssh://%s@%s:49022/lol.git", uid, host)
c.Assert(remote, gocheck.Equals, expected)
}
func (s *S) TestList(c *check.C) {
config.Set("routers:router1:type", "foo")
config.Set("routers:router2:type", "bar")
defer config.Unset("routers:router1")
defer config.Unset("routers:router2")
expected := []PlanRouter{
{Name: "router1", Type: "foo"},
{Name: "router2", Type: "bar"},
}
routers, err := List()
c.Assert(err, check.IsNil)
c.Assert(routers, check.DeepEquals, expected)
}
func (s *S) TestDbConfig(c *check.C) {
oldURL, _ := config.Get("database:url")
defer config.Set("database:url", oldURL)
oldName, _ := config.Get("database:name")
defer config.Set("database:name", oldName)
url, dbname := DbConfig()
c.Assert(url, check.Equals, oldURL)
c.Assert(dbname, check.Equals, oldName)
config.Unset("database:url")
config.Unset("database:name")
url, dbname = DbConfig()
c.Assert(url, check.Equals, "127.0.0.1:27017")
c.Assert(dbname, check.Equals, "gandalf")
}
func (s *S) TestHealerHealNodeDestroyError(c *check.C) {
factory, iaasInst := iaasTesting.NewHealerIaaSConstructorWithInst("addr1")
iaasInst.DelErr = fmt.Errorf("my destroy error")
iaas.RegisterIaasProvider("my-healer-iaas", factory)
_, err := iaas.CreateMachineForIaaS("my-healer-iaas", map[string]string{})
c.Assert(err, check.IsNil)
iaasInst.Addr = "addr2"
config.Set("iaas:node-protocol", "http")
config.Set("iaas:node-port", 2)
defer config.Unset("iaas:node-protocol")
defer config.Unset("iaas:node-port")
p := provisiontest.ProvisionerInstance
err = p.AddNode(provision.AddNodeOptions{
Address: "http://addr1:1",
Metadata: map[string]string{"iaas": "my-healer-iaas"},
})
c.Assert(err, check.IsNil)
healer := newNodeHealer(nodeHealerArgs{
WaitTimeNewMachine: time.Minute,
})
healer.Shutdown()
nodes, err := p.ListNodes(nil)
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Address(), check.Equals, "http://addr1:1")
machines, err := iaas.ListMachines()
c.Assert(err, check.IsNil)
c.Assert(machines, check.HasLen, 1)
c.Assert(machines[0].Address, check.Equals, "addr1")
buf := bytes.Buffer{}
log.SetLogger(log.NewWriterLogger(&buf, false))
defer log.SetLogger(nil)
created, err := healer.healNode(nodes[0])
c.Assert(err, check.IsNil)
c.Assert(created.Address, check.Equals, "http://addr2:2")
c.Assert(buf.String(), check.Matches, "(?s).*my destroy error.*")
nodes, err = p.ListNodes(nil)
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Address(), check.Equals, "http://addr2:2")
machines, err = iaas.ListMachines()
c.Assert(err, check.IsNil)
c.Assert(machines, check.HasLen, 1)
c.Assert(machines[0].Address, check.Equals, "addr2")
}
func (s *S) TestResetSuccessWithWrongTemplate(c *check.C) {
config.Set("reset-password-successfully-template", "testdata/wrong-email-reset-success.txt")
defer config.Unset("reset-password-successfully-template")
tmp, err := getEmailResetPasswordSucessfullyTemplate()
c.Assert(tmp, check.IsNil)
c.Assert(err, check.NotNil)
}
func (s *S) TestResetWithNotFoundTemplate(c *check.C) {
config.Set("reset-password-template", "testdata/wrong-email-reset-password.txt")
defer config.Unset("reset-password-template")
tmp, err := getEmailResetPasswordTemplate()
c.Assert(tmp, check.IsNil)
c.Assert(err, check.NotNil)
}
func (s *S) TestBuildImageNameWithRegistry(c *gocheck.C) {
config.Set("docker:registry", "localhost:3030")
defer config.Unset("docker:registry")
repository := assembleImageName("raising")
expected := "localhost:3030/" + s.repoNamespace + "/raising"
c.Assert(repository, gocheck.Equals, expected)
}
