func (s *archSuite) TestNormaliseArch(c *gc.C) {
for _, test := range []struct {
raw string
arch string
}{
{"windows", "windows"},
{"amd64", "amd64"},
{"x86_64", "amd64"},
{"386", "i386"},
{"i386", "i386"},
{"i486", "i386"},
{"arm", "armhf"},
{"armv", "armhf"},
{"armv7", "armhf"},
{"aarch64", "arm64"},
{"arm64", "arm64"},
{"ppc64el", "ppc64el"},
{"ppc64le", "ppc64el"},
{"ppc64", "ppc64el"},
{"s390x", "s390x"},
} {
arch := arch.NormaliseArch(test.raw)
c.Check(arch, gc.Equals, test.arch)
}
}
func detectSeriesAndHardwareCharacteristics(host string) (hc instance.HardwareCharacteristics, series string, err error) {
logger.Infof("Detecting series and characteristics on %s", host)
cmd := ssh.Command("ubuntu@"+host, []string{"/bin/bash"}, nil)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
cmd.Stdin = bytes.NewBufferString(detectionScript)
if err := cmd.Run(); err != nil {
if stderr.Len() != 0 {
err = fmt.Errorf("%v (%v)", err, strings.TrimSpace(stderr.String()))
}
return hc, "", err
}
lines := strings.Split(stdout.String(), "\n")
series = strings.TrimSpace(lines[0])
arch := arch.NormaliseArch(lines[1])
hc.Arch = &arch
// HardwareCharacteristics wants memory in megabytes,
// meminfo reports it in kilobytes.
memkB := strings.Fields(lines[2])[1] // "MemTotal: NNN kB"
hc.Mem = new(uint64)
*hc.Mem, err = strconv.ParseUint(memkB, 10, 0)
*hc.Mem /= 1024
// For each "physical id", count the number of cores.
// This way we only count physical cores, not additional
// logical cores due to hyperthreading.
recorded := make(map[string]bool)
var physicalId string
hc.CpuCores = new(uint64)
for _, line := range lines[3:] {
if strings.HasPrefix(line, "physical id") {
physicalId = strings.TrimSpace(strings.SplitN(line, ":", 2)[1])
} else if strings.HasPrefix(line, "cpu cores") {
var cores uint64
value := strings.TrimSpace(strings.SplitN(line, ":", 2)[1])
if cores, err = strconv.ParseUint(value, 10, 0); err != nil {
return hc, "", err
}
if !recorded[physicalId] {
*hc.CpuCores += cores
recorded[physicalId] = true
}
}
}
if *hc.CpuCores == 0 {
// In the case of a single-core, non-HT CPU, we'll see no
// "physical id" or "cpu cores" lines.
*hc.CpuCores = 1
}
// TODO(axw) calculate CpuPower. What algorithm do we use?
logger.Infof("series: %s, characteristics: %s", series, hc)
return hc, series, nil
}
func newInstanceSummary(info *shared.ContainerState) InstanceSummary {
archStr, _ := shared.ArchitectureName(info.Architecture)
archStr = arch.NormaliseArch(archStr)
var numCores uint = 0 // default to all
if raw := info.Config["limits.cpus"]; raw != "" {
fmt.Sscanf(raw, "%d", &numCores)
}
var mem uint = 0 // default to all
if raw := info.Config["limits.memory"]; raw != "" {
fmt.Sscanf(raw, "%d", &mem)
}
var addrs []network.Address
for _, info := range info.Status.Ips {
addr := network.NewAddress(info.Address)
// Ignore loopback devices.
// TODO(ericsnow) Move the loopback test to a network.Address method?
ip := net.ParseIP(addr.Value)
if ip != nil && ip.IsLoopback() {
continue
}
addrs = append(addrs, addr)
}
// TODO(ericsnow) Factor this out into a function.
statusStr := info.Status.Status
for status, code := range allStatuses {
if info.Status.StatusCode == code {
statusStr = status
break
}
}
metadata := extractMetadata(info.Config)
return InstanceSummary{
Name: info.Name,
Status: statusStr,
Metadata: metadata,
Addresses: addrs,
Hardware: InstanceHardware{
Architecture: archStr,
NumCores: numCores,
MemoryMB: mem,
},
}
}
func newInstanceSummary(info *shared.ContainerInfo) InstanceSummary {
archStr := arch.NormaliseArch(info.Architecture)
var numCores uint = 0 // default to all
if raw := info.Config["limits.cpu"]; raw != "" {
fmt.Sscanf(raw, "%d", &numCores)
}
var mem uint = 0 // default to all
if raw := info.Config["limits.memory"]; raw != "" {
result, err := shared.ParseByteSizeString(raw)
if err != nil {
logger.Errorf("failed to parse %s into bytes, ignoring err: %s", raw, err)
mem = 0
} else {
// We're going to put it into MemoryMB, so adjust by a megabyte
result = result / megabyte
if result > math.MaxUint32 {
logger.Errorf("byte string %s overflowed uint32", raw)
mem = math.MaxUint32
} else {
mem = uint(result)
}
}
}
// TODO(ericsnow) Factor this out into a function.
statusStr := info.Status
for status, code := range allStatuses {
if info.StatusCode == code {
statusStr = status
break
}
}
metadata := extractMetadata(info.Config)
return InstanceSummary{
Name: info.Name,
Status: statusStr,
Metadata: metadata,
Hardware: InstanceHardware{
Architecture: archStr,
NumCores: numCores,
MemoryMB: mem,
},
}
}
func (s *kvmProvisionerSuite) TestContainerStartedAndStopped(c *gc.C) {
if arch.NormaliseArch(runtime.GOARCH) != arch.AMD64 {
c.Skip("Test only enabled on amd64, see bug lp:1572145")
}
p := s.newKvmProvisioner(c)
defer stop(c, p)
container := s.addContainer(c)
instId := s.expectStarted(c, container)
// ...and removed, along with the machine, when the machine is Dead.
c.Assert(container.EnsureDead(), gc.IsNil)
s.expectStopped(c, instId)
s.waitForRemovalMark(c, container)
}
// SkipIfI386 skips the test if the arch is I386.
func SkipIfI386(c *gc.C, bugID string) {
if arch.NormaliseArch(runtime.GOARCH) == arch.I386 {
c.Skip(fmt.Sprintf("Test disabled on I386 until fixed - see bug %s", bugID))
}
}
// SkipIfPPC64EL skips the test if the arch is PPC64EL and the
// compiler is gccgo.
func SkipIfPPC64EL(c *gc.C, bugID string) {
if runtime.Compiler == "gccgo" &&
arch.NormaliseArch(runtime.GOARCH) == arch.PPC64EL {
c.Skip(fmt.Sprintf("Test disabled on PPC64EL until fixed - see bug %s", bugID))
}
}