// Reads a log file. func (c *combiner) read(fileName string) error { fh, err := os.Open(fileName) if err != nil { return err } defer fh.Close() scanner := bufio.NewScanner(fh) for j := 0; scanner.Scan(); j++ { line := scanner.Text() if j == 0 { fields := strings.Fields(string(line)) if len(c.headers) == 0 { c.ts = fields[0] c.headers = fields[1:] } else if len(c.headers) > len(fields[1:]) { c.headers = fields[1:] } } else if j > 1 { fields := strings.Fields(line) ts, _ := strconv.ParseInt(fields[0], 10, 64) c.entries[int(ts)] = fields[1:] } } // check for scanner errors return nil }
func (pfs *ProcFS) Get(k string) { var uf = path.Join(procfsdir, "uptime") switch k { case PROCFS_SELF: var selfdir = path.Join(procfsdir, "self") if !exists(selfdir) { return } fi, _ := os.Readlink(selfdir) pfs.Self = fi case PROCFS_UPTIME: str, err := ioutil.ReadFile(uf) if err == nil { ss := strings.Fields(string(str)) if len(ss) >= 2 { it, _ := strconv.ParseFloat(ss[0], 64) pfs.Uptime = int(it) } } case PROCFS_IDLETIME: str, err := ioutil.ReadFile(uf) if err == nil { ss := strings.Fields(string(str)) if len(ss) >= 2 { it, _ := strconv.ParseFloat(ss[1], 64) pfs.Idletime = int(it) } } case PROCFS_MOUNTS: pfs.Mounts = getMounts(path.Join(procfsdir, "mounts")) } }
func ReadSNMP(path string) (*Snmp, error) { data, err := ioutil.ReadFile(path) if err != nil { return nil, err } lines := strings.Split(string(data), "\n") // Maps a netstat metric to its value (i.e. SyncookiesSent --> 0) statMap := make(map[string]string) // patterns // TcpExt: SyncookiesSent SyncookiesRecv SyncookiesFailed... <-- header // TcpExt: 0 0 1764... <-- values for i := 1; i < len(lines); i = i + 2 { headers := strings.Fields(lines[i-1][strings.Index(lines[i-1], ":")+1:]) values := strings.Fields(lines[i][strings.Index(lines[i], ":")+1:]) for j, header := range headers { statMap[header] = values[j] } } out := Snmp{} elem := reflect.ValueOf(&out.TCP).Elem() typeOfElem := elem.Type() for i := 0; i < elem.NumField(); i++ { if val, ok := statMap[typeOfElem.Field(i).Name]; ok { parsedVal, _ := strconv.ParseUint(val, 10, 64) elem.Field(i).SetUint(parsedVal) } } return &out, nil }
// Parse parses a Makefile into a *Makefile struct. // // TODO(sqs): super hacky. func Parse(data []byte) (*Makefile, error) { var mf Makefile lines := bytes.Split(data, []byte{'\n'}) var rule *BasicRule for lineno, lineBytes := range lines { line := string(lineBytes) if strings.HasPrefix(line, "\t") { if rule == nil { return nil, fmt.Errorf("line %d: indented recipe not inside a rule", lineno) } recipe := strings.TrimPrefix(line, "\t") recipe = ExpandAutoVars(rule, recipe) rule.RecipeCmds = append(rule.RecipeCmds, recipe) } else if strings.Contains(line, ":") { sep := strings.Index(line, ":") targets := strings.Fields(line[:sep]) if len(targets) > 1 { return nil, errMultipleTargetsUnsupported(lineno) } target := targets[0] prereqs := strings.Fields(line[sep+1:]) prereqs = uniqAndSort(prereqs) rule = &BasicRule{TargetFile: target, PrereqFiles: prereqs} mf.Rules = append(mf.Rules, rule) } else { rule = nil } } return &mf, nil }
func GetStudent(d *goquery.Document, rollno int) (s Student, ok bool) { //sanity on document // if v := d.Find(".titlehead").Children().Text(); v != "JEE (Advanced) - 2013 Result" { // return Student{}, false // } dtext := strings.Trim(d.Text(), " ") dfields := strings.Fields(dtext) for _, v := range dfields { s.Plaintext += v + " " } s.Plaintext = strings.Trim(s.Plaintext, " ") if isInvalid(dtext) { return s, false } ok = true s.Rollno = rollno s.Region = s.Rollno / 10000 if !isSelected(dtext) { return } s.Selected = true s.Rank, _ = strconv.Atoi(d.Find(".style7").First().Text()) text, _ := d.Find(".titlehead").First().Parent().Next().Children().Children().First().Html() tokens := strings.Split(text, "<br/>") nameToks := strings.Fields(tokens[1]) nameToks = nameToks[2:len(nameToks)] for _, v := range nameToks { s.Name += v + " " } s.Name = strings.Trim(s.Name, " ") s.Q = GetQuota(dtext) return }
func TestEventsImageUntagDelete(t *testing.T) { name := "testimageevents" defer deleteImages(name) _, err := buildImage(name, `FROM scratch MAINTAINER "docker"`, true) if err != nil { t.Fatal(err) } if err := deleteImages(name); err != nil { t.Fatal(err) } eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(t).Unix())) out, exitCode, err := runCommandWithOutput(eventsCmd) if exitCode != 0 || err != nil { t.Fatalf("Failed to get events with exit code %d: %s", exitCode, err) } events := strings.Split(out, "\n") events = events[:len(events)-1] if len(events) < 2 { t.Fatalf("Missing expected event") } untagEvent := strings.Fields(events[len(events)-2]) deleteEvent := strings.Fields(events[len(events)-1]) if untagEvent[len(untagEvent)-1] != "untag" { t.Fatalf("untag should be untag, not %#v", untagEvent) } if deleteEvent[len(deleteEvent)-1] != "delete" { t.Fatalf("delete should be delete, not %#v", deleteEvent) } logDone("events - image untag, delete is logged") }
func TestEventsContainerEvents(t *testing.T) { dockerCmd(t, "run", "--rm", "busybox", "true") eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(t).Unix())) out, exitCode, err := runCommandWithOutput(eventsCmd) if exitCode != 0 || err != nil { t.Fatalf("Failed to get events with exit code %d: %s", exitCode, err) } events := strings.Split(out, "\n") events = events[:len(events)-1] if len(events) < 4 { t.Fatalf("Missing expected event") } createEvent := strings.Fields(events[len(events)-4]) startEvent := strings.Fields(events[len(events)-3]) dieEvent := strings.Fields(events[len(events)-2]) destroyEvent := strings.Fields(events[len(events)-1]) if createEvent[len(createEvent)-1] != "create" { t.Fatalf("event should be create, not %#v", createEvent) } if startEvent[len(startEvent)-1] != "start" { t.Fatalf("event should be start, not %#v", startEvent) } if dieEvent[len(dieEvent)-1] != "die" { t.Fatalf("event should be die, not %#v", dieEvent) } if destroyEvent[len(destroyEvent)-1] != "destroy" { t.Fatalf("event should be destroy, not %#v", destroyEvent) } logDone("events - container create, start, die, destroy is logged") }
func getRootfsDM(containerID string) (string, error) { var ( rootfs string major string minor string ) out, err := exec.Command("ls", "-lh", "/dev/mapper").CombinedOutput() if err != nil { return "", err } for _, line := range strings.Split(string(out), "\n") { fields := strings.Fields(line) if strings.Contains(line, containerID) { if len(fields) < 10 { return "", fmt.Errorf("Failed to get /dev/mapper info") } rootfs = filepath.Base(fields[10]) break } } out, err = exec.Command("ls", "-lh", filepath.Join("/dev", rootfs)).CombinedOutput() if err != nil { return "", err } fields := strings.Fields(string(out)) if len(fields) < 5 { return "", fmt.Errorf("Failed to get /dev/%s info", rootfs) } major = strings.Replace(fields[4], ",", "", -1) minor = fields[5] return fmt.Sprintf("%s:%s", major, minor), nil }
func readBondingStats(root string) (status map[string][2]int, err error) { status = map[string][2]int{} masters, err := ioutil.ReadFile(path.Join(root, "bonding_masters")) if err != nil { return nil, err } for _, master := range strings.Fields(string(masters)) { slaves, err := ioutil.ReadFile(path.Join(root, master, "bonding", "slaves")) if err != nil { return nil, err } sstat := [2]int{0, 0} for _, slave := range strings.Fields(string(slaves)) { state, err := ioutil.ReadFile(path.Join(root, master, fmt.Sprintf("lower_%s", slave), "operstate")) if os.IsNotExist(err) { // some older? kernels use slave_ prefix state, err = ioutil.ReadFile(path.Join(root, master, fmt.Sprintf("slave_%s", slave), "operstate")) } if err != nil { return nil, err } sstat[0]++ if strings.TrimSpace(string(state)) == "up" { sstat[1]++ } } status[master] = sstat } return status, err }
func parseIrcLine(line string) (prefix, command string, args []string) { if line == "" { logger.Printf("cannot parse %q", line) return } var hasPrefix bool if line[0] == ':' { hasPrefix = true } var items []string colon := strings.Index(line[1:], ":") if colon >= 0 { // long arg items = strings.Fields(line[:colon+1]) items = append(items, line[colon+2:]) } else { items = strings.Fields(line) } if len(items) < 2 { logger.Printf("cannot parse %q", line) return } if hasPrefix { return items[0][1:], items[1], items[2:] } return "", items[0], items[1:] }
func (self *ProcMem) Get(pid int) error { contents, err := readProcFile(pid, "statm") if err != nil { return err } fields := strings.Fields(string(contents)) size, _ := strtoull(fields[0]) self.Size = size << 12 rss, _ := strtoull(fields[1]) self.Resident = rss << 12 share, _ := strtoull(fields[2]) self.Share = share << 12 contents, err = readProcFile(pid, "stat") if err != nil { return err } fields = strings.Fields(string(contents)) self.MinorFaults, _ = strtoull(fields[10]) self.MajorFaults, _ = strtoull(fields[12]) self.PageFaults = self.MinorFaults + self.MajorFaults return nil }
func (v *ViPR) discover(cli *http.Client, url string) (map[string]string, error) { user := env(v.Username, "VIPR_USERNAME", "Admin") password := env(v.Password, "VIPR_PASSWORD", "ADMINISTRATOR") request, err := http.NewRequest("GET", url, nil) if err != nil { return nil, err } request.SetBasicAuth(user, password) resp, err := cli.Do(request) if resp == nil || err != nil { return nil, err } defer resp.Body.Close() doc, err := goquery.NewDocumentFromResponse(resp) if doc == nil || err != nil { return nil, err } results := make(map[string]string) // mac address is hidden in javascript and non changeable doc.Find("td").Each(func(i int, s *goquery.Selection) { p := strings.Fields(s.Text()) if len(p) > 0 && s.Next() != nil { r := strings.Fields(strings.Replace(s.Next().Text(), "\"", "", -1)) if strings.HasPrefix(s.Text(), "Dataradio") { results["version"] = strings.Join(p, " ") } if strings.HasPrefix(s.Text(), "MAC") { if _, ok := results["macaddr"]; !ok && len(r) > 10 { results["macaddr"] = strings.Join(r[5:10], ":") } } if strings.HasPrefix(s.Text(), "RSSI") { if len(r) > 1 { results["signal"] = r[0] } } switch strings.Join(p, " ") { case "Modem Firmware Version": results["firmware"] = strings.Replace(strings.Replace(strings.Join(r, " "), "(", "", -1), ")", "", -1) case "Station Name": results["name"] = strings.Join(r, " ") case "Unit Status": results["status"] = strings.Join(r, " ") case "DC Input Voltage": results["supply"] = strings.Join(r, " ") case "Transceiver Temperature": results["temperature"] = strings.Join(r, " ") } } }) return results, nil }
func TestEventsPause(t *testing.T) { out, _, _ := cmd(t, "images", "-q") image := strings.Split(out, "\n")[0] cmd(t, "run", "-d", "--name", "testeventpause", image, "sleep", "2") cmd(t, "pause", "testeventpause") cmd(t, "unpause", "testeventpause") eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", time.Now().Unix())) out, _, _ = runCommandWithOutput(eventsCmd) events := strings.Split(out, "\n") if len(events) <= 1 { t.Fatalf("Missing expected event") } pauseEvent := strings.Fields(events[len(events)-3]) unpauseEvent := strings.Fields(events[len(events)-2]) if pauseEvent[len(pauseEvent)-1] != "pause" { t.Fatalf("event should be pause, not %#v", pauseEvent) } if unpauseEvent[len(unpauseEvent)-1] != "unpause" { t.Fatalf("event should be pause, not %#v", unpauseEvent) } logDone("events - pause/unpause is logged") }
func Command(cmd string) []string { command := []byte(strings.ToLower(cmd)) if what_time.Match(command) { current_time := time.LocalTime() formatted_time := current_time.Format(time.Kitchen) return []string{formatted_time} } else if who_are_you.Match(command) { return []string{"I am Gopher, I'm here to help."} } else if cmd == "gopher quit" { os.Exit(0) } else if matches := gist.FindSubmatch(command); matches != nil { for _, match := range matches { fmt.Printf("Match: %s\n", string(match)) } if len(matches) > 1 { gist_id, err := strconv.Atoui(string(matches[1])) if err != nil { fmt.Printf("Could not parse the gist_id: %s\n", string(matches[1])) return []string{} } gist_file := strings.TrimSpace(string(matches[2])) fmt.Printf("Gist file: %s\n", gist_file) gist_content := GetGist(gist_id, gist_file) fmt.Printf("Gist Content: %s\n", gist_content) return gist_content } return []string{} } else if matches := hoogle.FindSubmatch([]byte(cmd)); matches != nil { return Hoogle(strings.Fields(string(matches[1]))) } else if matches := man_page.FindSubmatch([]byte(cmd)); matches != nil { return Manpage(strings.Fields(string(matches[1]))) } return []string{"Dunno what you are asking me. WTF dude?"} }
// TestPullAllTagsFromCentralRegistry pulls using `all-tags` for a given image and verifies that it // results in more images than a naked pull. func (s *DockerHubPullSuite) TestPullAllTagsFromCentralRegistry(c *check.C) { testRequires(c, DaemonIsLinux) s.Cmd(c, "pull", "busybox") outImageCmd := s.Cmd(c, "images", "busybox") splitOutImageCmd := strings.Split(strings.TrimSpace(outImageCmd), "\n") c.Assert(splitOutImageCmd, checker.HasLen, 2, check.Commentf("expected a single entry in images\n%v", outImageCmd)) s.Cmd(c, "pull", "--all-tags=true", "busybox") outImageAllTagCmd := s.Cmd(c, "images", "busybox") if linesCount := strings.Count(outImageAllTagCmd, "\n"); linesCount <= 2 { c.Fatalf("pulling all tags should provide more images, got %d", linesCount-1) } // Verify that the line for 'busybox:latest' is left unchanged. var latestLine string for _, line := range strings.Split(outImageAllTagCmd, "\n") { if strings.HasPrefix(line, "busybox") && strings.Contains(line, "latest") { latestLine = line break } } c.Assert(latestLine, checker.Not(checker.Equals), "", check.Commentf("no entry for busybox:latest found after pulling all tags")) splitLatest := strings.Fields(latestLine) splitCurrent := strings.Fields(splitOutImageCmd[1]) c.Assert(splitLatest, checker.DeepEquals, splitCurrent, check.Commentf("busybox:latest was changed after pulling all tags")) }
func (s *DockerSuite) TestEventsContainerEvents(c *check.C) { testRequires(c, DaemonIsLinux) dockerCmd(c, "run", "--rm", "busybox", "true") out, _ := dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) events := strings.Split(out, "\n") events = events[:len(events)-1] if len(events) < 5 { c.Fatalf("Missing expected event") } createEvent := strings.Fields(events[len(events)-5]) attachEvent := strings.Fields(events[len(events)-4]) startEvent := strings.Fields(events[len(events)-3]) dieEvent := strings.Fields(events[len(events)-2]) destroyEvent := strings.Fields(events[len(events)-1]) if createEvent[len(createEvent)-1] != "create" { c.Fatalf("event should be create, not %#v", createEvent) } if attachEvent[len(createEvent)-1] != "attach" { c.Fatalf("event should be attach, not %#v", attachEvent) } if startEvent[len(startEvent)-1] != "start" { c.Fatalf("event should be start, not %#v", startEvent) } if dieEvent[len(dieEvent)-1] != "die" { c.Fatalf("event should be die, not %#v", dieEvent) } if destroyEvent[len(destroyEvent)-1] != "destroy" { c.Fatalf("event should be destroy, not %#v", destroyEvent) } }
func (s *serviceSuite) TestNewConf(c *gc.C) { dataDir := "/var/lib/juju" dbDir := dataDir + "/db" mongodPath := "/mgo/bin/mongod" port := 12345 oplogSizeMB := 10 conf := mongo.NewConf(dataDir, dbDir, mongodPath, port, oplogSizeMB, false) expected := common.Conf{ Desc: "juju state database", Limit: map[string]int{ "nofile": 65000, "nproc": 20000, }, Timeout: 300, ExecStart: "/mgo/bin/mongod" + " --auth" + " --dbpath '/var/lib/juju/db'" + " --sslOnNormalPorts" + " --sslPEMKeyFile '/var/lib/juju/server.pem'" + " --sslPEMKeyPassword ignored" + " --port 12345" + " --noprealloc" + " --syslog" + " --smallfiles" + " --journal" + " --keyFile '/var/lib/juju/shared-secret'" + " --replSet juju" + " --ipv6" + " --oplogSize 10", } c.Check(conf, jc.DeepEquals, expected) c.Check(strings.Fields(conf.ExecStart), jc.DeepEquals, strings.Fields(expected.ExecStart)) }
func (s *DockerSuite) TestEventsContainerEventsSinceUnixEpoch(c *check.C) { testRequires(c, DaemonIsLinux) dockerCmd(c, "run", "--rm", "busybox", "true") timeBeginning := time.Unix(0, 0).Format(time.RFC3339Nano) timeBeginning = strings.Replace(timeBeginning, "Z", ".000000000Z", -1) out, _ := dockerCmd(c, "events", fmt.Sprintf("--since='%s'", timeBeginning), fmt.Sprintf("--until=%d", daemonTime(c).Unix())) events := strings.Split(out, "\n") events = events[:len(events)-1] if len(events) < 5 { c.Fatalf("Missing expected event") } createEvent := strings.Fields(events[len(events)-5]) attachEvent := strings.Fields(events[len(events)-4]) startEvent := strings.Fields(events[len(events)-3]) dieEvent := strings.Fields(events[len(events)-2]) destroyEvent := strings.Fields(events[len(events)-1]) if createEvent[len(createEvent)-1] != "create" { c.Fatalf("event should be create, not %#v", createEvent) } if attachEvent[len(attachEvent)-1] != "attach" { c.Fatalf("event should be attach, not %#v", attachEvent) } if startEvent[len(startEvent)-1] != "start" { c.Fatalf("event should be start, not %#v", startEvent) } if dieEvent[len(dieEvent)-1] != "die" { c.Fatalf("event should be die, not %#v", dieEvent) } if destroyEvent[len(destroyEvent)-1] != "destroy" { c.Fatalf("event should be destroy, not %#v", destroyEvent) } }
func TestEventsContainerFailStartDie(t *testing.T) { defer deleteAllContainers() out, _, _ := dockerCmd(t, "images", "-q") image := strings.Split(out, "\n")[0] eventsCmd := exec.Command(dockerBinary, "run", "--name", "testeventdie", image, "blerg") _, _, err := runCommandWithOutput(eventsCmd) if err == nil { t.Fatalf("Container run with command blerg should have failed, but it did not") } eventsCmd = exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(t).Unix())) out, _, _ = runCommandWithOutput(eventsCmd) events := strings.Split(out, "\n") if len(events) <= 1 { t.Fatalf("Missing expected event") } startEvent := strings.Fields(events[len(events)-3]) dieEvent := strings.Fields(events[len(events)-2]) if startEvent[len(startEvent)-1] != "start" { t.Fatalf("event should be start, not %#v", startEvent) } if dieEvent[len(dieEvent)-1] != "die" { t.Fatalf("event should be die, not %#v", dieEvent) } logDone("events - container unwilling to start logs die") }
func (s *DockerSuite) TestEventsImageUntagDelete(c *check.C) { testRequires(c, DaemonIsLinux) name := "testimageevents" _, err := buildImage(name, `FROM scratch MAINTAINER "docker"`, true) if err != nil { c.Fatal(err) } if err := deleteImages(name); err != nil { c.Fatal(err) } out, _ := dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) events := strings.Split(out, "\n") events = events[:len(events)-1] if len(events) < 2 { c.Fatalf("Missing expected event") } untagEvent := strings.Fields(events[len(events)-2]) deleteEvent := strings.Fields(events[len(events)-1]) if untagEvent[len(untagEvent)-1] != "untag" { c.Fatalf("untag should be untag, not %#v", untagEvent) } if deleteEvent[len(deleteEvent)-1] != "delete" { c.Fatalf("delete should be delete, not %#v", deleteEvent) } }
func parseInterrupts(r io.Reader) (map[string]interrupt, error) { var ( interrupts = map[string]interrupt{} scanner = bufio.NewScanner(r) ) if !scanner.Scan() { return nil, errors.New("interrupts empty") } cpuNum := len(strings.Fields(string(scanner.Text()))) // one header per cpu for scanner.Scan() { line := scanner.Text() parts := strings.Fields(string(line)) if len(parts) < cpuNum+2 { // irq + one column per cpu + details, continue // we ignore ERR and MIS for now } intName := parts[0][:len(parts[0])-1] // remove trailing : intr := interrupt{ values: parts[1:cpuNum], } if _, err := strconv.Atoi(intName); err == nil { // numeral interrupt intr.info = parts[cpuNum+1] intr.devices = strings.Join(parts[cpuNum+2:], " ") } else { intr.info = strings.Join(parts[cpuNum+1:], " ") } interrupts[intName] = intr } return interrupts, nil }
func (s *DockerSuite) TestEventsContainerEvents(c *check.C) { dockerCmd(c, "run", "--rm", "busybox", "true") eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) out, exitCode, err := runCommandWithOutput(eventsCmd) if exitCode != 0 || err != nil { c.Fatalf("Failed to get events with exit code %d: %s", exitCode, err) } events := strings.Split(out, "\n") events = events[:len(events)-1] if len(events) < 5 { c.Fatalf("Missing expected event") } createEvent := strings.Fields(events[len(events)-5]) attachEvent := strings.Fields(events[len(events)-4]) startEvent := strings.Fields(events[len(events)-3]) dieEvent := strings.Fields(events[len(events)-2]) destroyEvent := strings.Fields(events[len(events)-1]) if createEvent[len(createEvent)-1] != "create" { c.Fatalf("event should be create, not %#v", createEvent) } if attachEvent[len(createEvent)-1] != "attach" { c.Fatalf("event should be attach, not %#v", attachEvent) } if startEvent[len(startEvent)-1] != "start" { c.Fatalf("event should be start, not %#v", startEvent) } if dieEvent[len(dieEvent)-1] != "die" { c.Fatalf("event should be die, not %#v", dieEvent) } if destroyEvent[len(destroyEvent)-1] != "destroy" { c.Fatalf("event should be destroy, not %#v", destroyEvent) } }
func (s *DockerSuite) TestPause(c *check.C) { testRequires(c, DaemonIsLinux) defer unpauseAllContainers() name := "testeventpause" dockerCmd(c, "run", "-d", "--name", name, "busybox", "top") dockerCmd(c, "pause", name) pausedContainers, err := getSliceOfPausedContainers() c.Assert(err, checker.IsNil) c.Assert(len(pausedContainers), checker.Equals, 1) dockerCmd(c, "unpause", name) out, _ := dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) events := strings.Split(out, "\n") c.Assert(len(events) > 1, checker.Equals, true) pauseEvent := strings.Fields(events[len(events)-3]) unpauseEvent := strings.Fields(events[len(events)-2]) c.Assert(pauseEvent[len(pauseEvent)-1], checker.Equals, "pause") c.Assert(unpauseEvent[len(unpauseEvent)-1], checker.Equals, "unpause") }
func (s *DockerSuite) TestEventsContainerFailStartDie(c *check.C) { out, _ := dockerCmd(c, "images", "-q") image := strings.Split(out, "\n")[0] if err := exec.Command(dockerBinary, "run", "--name", "testeventdie", image, "blerg").Run(); err == nil { c.Fatalf("Container run with command blerg should have failed, but it did not") } eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix())) out, _, _ = runCommandWithOutput(eventsCmd) events := strings.Split(out, "\n") if len(events) <= 1 { c.Fatalf("Missing expected event") } startEvent := strings.Fields(events[len(events)-3]) dieEvent := strings.Fields(events[len(events)-2]) if startEvent[len(startEvent)-1] != "start" { c.Fatalf("event should be start, not %#v", startEvent) } if dieEvent[len(dieEvent)-1] != "die" { c.Fatalf("event should be die, not %#v", dieEvent) } }
// call pkg-config and return the cflags and ldflags. func pkgconfig(p *Package) ([]string, []string, error) { if len(p.CgoPkgConfig) == 0 { return nil, nil, nil // nothing to do } args := []string{ "--cflags", } args = append(args, p.CgoPkgConfig...) var out bytes.Buffer err := p.runOut(&out, p.Dir, nil, "pkg-config", args...) if err != nil { return nil, nil, err } cflags := strings.Fields(out.String()) args = []string{ "--libs", } args = append(args, p.CgoPkgConfig...) out.Reset() err = p.runOut(&out, p.Dir, nil, "pkg-config", args...) if err != nil { return nil, nil, err } ldflags := strings.Fields(out.String()) return cflags, ldflags, nil }
// checks if partial is any of the words or phrases within whole func phrasesMatch(partial, whole string) bool { // create words of whole words := strings.Fields(whole) // tag partial apart and put it back together with standard space partials := strings.Fields(partial) partialWords := len(partials) partial = strings.Join(partials, " ") // check if partial matches any of whole's phrases for i := 0; (i + partialWords) <= len(words); i++ { slidingBit := strings.Join(words[i:(i+partialWords)], " ") if strings.EqualFold(slidingBit, partial) { return true } if strings.HasSuffix(slidingBit, "'s") { if strings.EqualFold(strings.TrimSuffix(slidingBit, "'s"), partial) { return true } } } return false }
//getInitialProcStatData gets number of CPUs and number of metrics available in /proc/stat output func getInitialProcStatData(path string) (cpuMetricsNumber int, procStatMetricNumber int, err error) { fh, err := os.Open(path) if err != nil { return cpuMetricsNumber, procStatMetricNumber, err } defer fh.Close() scanner := bufio.NewScanner(fh) //read the first line to start the loop scanErr := scanner.Scan() if scanErr != true { return cpuMetricsNumber, procStatMetricNumber, fmt.Errorf("Cannot read from %s", path) } procStatLine := strings.Fields(scanner.Text()) procStatMetricNumber = len(procStatLine) - 1 //without cpu identifier (e.g. cpu or cpu0) cpuMetricsNumber = 0 for strings.Contains(procStatLine[0], cpuStr) { //check line length, compare current length with length of the first line //length of the first line = len(procStatMetricNumber) + CPU identifier if len(procStatLine) != (procStatMetricNumber + 1) { return cpuMetricsNumber, procStatMetricNumber, fmt.Errorf("Incorrect %s output", path) } cpuMetricsNumber++ //read the next line to be able to check loop condition scanErr = scanner.Scan() if scanErr != true { break //no more lines to read } procStatLine = strings.Fields(scanner.Text()) } return cpuMetricsNumber, procStatMetricNumber, err }
// TestBidiCore performs the tests in BidiTest.txt. // See http://www.unicode.org/Public/UCD/latest/ucd/BidiTest.txt. func TestBidiCore(t *testing.T) { testtext.SkipIfNotLong(t) r := gen.OpenUCDFile("BidiTest.txt") defer r.Close() var wantLevels, wantOrder []string p := ucd.New(r, ucd.Part(func(p *ucd.Parser) { s := strings.Split(p.String(0), ":") switch s[0] { case "Levels": wantLevels = strings.Fields(s[1]) case "Reorder": wantOrder = strings.Fields(s[1]) default: log.Fatalf("Unknown part %q.", s[0]) } })) for p.Next() { types := []class{} for _, s := range p.Strings(0) { types = append(types, bidiClass[s]) } // We ignore the bracketing part of the algorithm. pairTypes := make([]bracketType, len(types)) pairValues := make([]rune, len(types)) for i := uint(0); i < 3; i++ { if p.Uint(1)&(1<<i) == 0 { continue } lev := level(int(i) - 1) par := newParagraph(types, pairTypes, pairValues, lev) if *testLevels { levels := par.resultLevels for i, s := range wantLevels { if s == "x" { continue } l, _ := strconv.ParseUint(s, 10, 8) if level(l)&1 != levels[i]&1 { t.Errorf("%s:%d:levels: got %v; want %v", p.String(0), lev, levels, wantLevels) break } } } order := par.getReordering([]int{len(types)}) gotOrder := filterOrder(types, order) if got, want := fmt.Sprint(gotOrder), fmt.Sprint(wantOrder); got != want { t.Errorf("%s:%d:order: got %v; want %v\noriginal %v", p.String(0), lev, got, want, order) } } } if err := p.Err(); err != nil { log.Fatal(err) } }
func TestMarshalParsePublicKey(t *testing.T) { pub, pubSerialized := getTestKey() line := fmt.Sprintf("%s %s user@host", pub.Type(), pubSerialized) authKeys := MarshalAuthorizedKey(pub) actualFields := strings.Fields(string(authKeys)) if len(actualFields) == 0 { t.Fatalf("failed authKeys: %v", authKeys) } // drop the comment expectedFields := strings.Fields(line)[0:2] if !reflect.DeepEqual(actualFields, expectedFields) { t.Errorf("got %v, expected %v", actualFields, expectedFields) } actPub, _, _, _, err := ParseAuthorizedKey([]byte(line)) if err != nil { t.Fatalf("cannot parse %v: %v", line, err) } if !reflect.DeepEqual(actPub, pub) { t.Errorf("got %v, expected %v", actPub, pub) } }
func killGotty(instanceid string) { cmd := exec.Command("sudo", "ps", "auxww") stdout, err := cmd.Output() if err != nil { return } lines := strings.Split(string(stdout), "\n") var recpid string for _, line := range lines { if strings.Contains(line, instanceid) { sudo := strings.Contains(line, "sudo") if !sudo { bhyve := strings.Contains(line, "bhyve") if !bhyve { recpid = strings.Fields(line)[1] cmd = exec.Command("sudo", "kill", recpid) cmd.Output() } } } } for _, line := range lines { if strings.Contains(line, instanceid) { gotty := strings.Contains(line, "gotty") if gotty { recpid = strings.Fields(line)[1] cmd = exec.Command("sudo", "kill", recpid) cmd.Output() } } } }