func collectUnit(container container, units chan<- provision.Unit, wg *sync.WaitGroup) {
defer wg.Done()
unit := provision.Unit{
Name: container.ID,
AppName: container.AppName,
Type: container.Type,
}
if container.Status == "error" {
unit.Status = provision.StatusDown
units <- unit
return
}
if container.Status == "running" {
unit.Ip = container.HostAddr
ip, hostPort, err := container.networkInfo()
if err == nil &&
(hostPort != container.HostPort || ip != container.IP) {
err = fixContainer(&container, ip, hostPort)
if err != nil {
log.Errorf("error on fix container hostport for [container %s]", container.ID)
return
}
}
addr := strings.Replace(container.getAddress(), "http://", "", 1)
conn, err := net.Dial("tcp", addr)
if err != nil {
unit.Status = provision.StatusUnreachable
} else {
conn.Close()
unit.Status = provision.StatusStarted
}
log.Debugf("collected data for [container %s] - [app %s]", container.ID, container.AppName)
units <- unit
}
}
func (s *S) TestContainerAsUnit(c *check.C) {
app := provisiontest.NewFakeApp("myapp", "python", 1)
expected := provision.Unit{
ID: "c-id",
AppName: "myapp",
Type: "python",
Ip: "192.168.50.4",
Status: provision.StatusBuilding,
ProcessName: "web",
Address: &url.URL{Scheme: "http", Host: "192.168.50.4:8080"},
}
container := Container{
ID: "c-id",
HostAddr: "192.168.50.4",
HostPort: "8080",
ProcessName: "web",
}
got := container.AsUnit(app)
c.Assert(got, check.DeepEquals, expected)
container.Type = "ruby"
container.Status = provision.StatusStarted.String()
got = container.AsUnit(app)
expected.Status = provision.StatusStarted
expected.Type = "ruby"
c.Assert(got, check.DeepEquals, expected)
}
func (p *JujuProvisioner) collectStatus() ([]provision.Unit, error) {
out, err := p.getOutput()
if err != nil {
return nil, err
}
var units []provision.Unit
for name, service := range out.Services {
for unitName, u := range service.Units {
machine := out.Machines[u.Machine]
unit := provision.Unit{
Name: unitName,
AppName: name,
Machine: u.Machine,
InstanceId: machine.InstanceID,
Ip: machine.IPAddress,
}
typeRegexp := regexp.MustCompile(`^(local:)?(\w+)/(\w+)-\d+$`)
matchs := typeRegexp.FindStringSubmatch(service.Charm)
if len(matchs) > 3 {
unit.Type = matchs[3]
}
unit.Status = unitStatus(machine, u, unit)
units = append(units, unit)
}
}
p.saveBootstrapMachine(out.Machines[0])
return units, err
}
func (p *FakeProvisioner) SetUnitStatus(unit provision.Unit, status provision.Status) error {
p.mut.Lock()
defer p.mut.Unlock()
var units []provision.Unit
if unit.AppName == "" {
units = p.getAllUnits()
} else {
app, ok := p.apps[unit.AppName]
if !ok {
return errNotProvisioned
}
units = app.units
}
index := -1
for i, unt := range units {
if unt.ID == unit.ID {
index = i
unit.AppName = unt.AppName
break
}
}
if index < 0 {
return &provision.UnitNotFoundError{ID: unit.ID}
}
app := p.apps[unit.AppName]
app.units[index].Status = status
p.apps[unit.AppName] = app
return nil
}
