func (s *S) TestFindNodeByAddrs(c *check.C) {
p := provisiontest.NewFakeProvisioner()
err := p.AddNode(provision.AddNodeOptions{
Address: "http://addr1",
})
c.Assert(err, check.IsNil)
node, err := provision.FindNodeByAddrs(p, []string{"addr1", "notfound"})
c.Assert(err, check.IsNil)
c.Assert(node.Address(), check.Equals, "http://addr1")
_, err = provision.FindNodeByAddrs(p, []string{"addr2"})
c.Assert(err, check.Equals, provision.ErrNodeNotFound)
}
func (p *swarmProvisioner) NodeForNodeData(nodeData provision.NodeStatusData) (provision.Node, error) {
client, err := chooseDBSwarmNode()
if err != nil {
if errors.Cause(err) == errNoSwarmNode {
return nil, provision.ErrNodeNotFound
}
}
tasks, err := client.ListTasks(docker.ListTasksOptions{})
if err != nil {
return nil, err
}
var task *swarm.Task
for _, unitData := range nodeData.Units {
task, err = findTaskByContainerId(tasks, unitData.ID)
if err == nil {
break
}
if _, isNotFound := errors.Cause(err).(*provision.UnitNotFoundError); !isNotFound {
return nil, err
}
}
if task != nil {
node, err := client.InspectNode(task.NodeID)
if err != nil {
if _, notFound := err.(*docker.NoSuchNode); notFound {
return nil, provision.ErrNodeNotFound
}
return nil, err
}
return &swarmNodeWrapper{Node: node, provisioner: p}, nil
}
return provision.FindNodeByAddrs(p, nodeData.Addrs)
}
func (s *S) TestFindNodeByAddrsAmbiguous(c *check.C) {
p := provisiontest.NewFakeProvisioner()
err := p.AddNode(provision.AddNodeOptions{
Address: "http://addr1",
})
c.Assert(err, check.IsNil)
err = p.AddNode(provision.AddNodeOptions{
Address: "http://addr2",
})
c.Assert(err, check.IsNil)
_, err = provision.FindNodeByAddrs(p, []string{"addr1", "addr2"})
c.Assert(err, check.ErrorMatches, `addrs match multiple nodes: \[addr1 addr2\]`)
}
func (p *dockerProvisioner) NodeForNodeData(nodeData provision.NodeStatusData) (provision.Node, error) {
nodes, err := p.Cluster().UnfilteredNodes()
if err != nil {
return nil, err
}
nodeSet := map[string]*cluster.Node{}
for i := range nodes {
nodeSet[net.URLToHost(nodes[i].Address)] = &nodes[i]
}
containerIDs := make([]string, 0, len(nodeData.Units))
containerNames := make([]string, 0, len(nodeData.Units))
for _, u := range nodeData.Units {
if u.ID != "" {
containerIDs = append(containerIDs, u.ID)
}
if u.Name != "" {
containerNames = append(containerNames, u.Name)
}
}
containersForNode, err := p.listContainersWithIDOrName(containerIDs, containerNames)
if err != nil {
return nil, err
}
var node *cluster.Node
for _, c := range containersForNode {
n := nodeSet[c.HostAddr]
if n != nil {
if node != nil && node.Address != n.Address {
return nil, errors.Errorf("containers match multiple nodes: %s and %s", node.Address, n.Address)
}
node = n
}
}
if node != nil {
return &clusterNodeWrapper{Node: node, prov: p}, nil
}
return provision.FindNodeByAddrs(p, nodeData.Addrs)
}
func (p *mesosProvisioner) NodeForNodeData(nodeData provision.NodeStatusData) (provision.Node, error) {
return provision.FindNodeByAddrs(p, nodeData.Addrs)
}