Golang ProcState.Get方法代码示例

func main() {
	pids := gosigar.ProcList{}
	pids.Get()

	// ps -eo pid,ppid,stime,time,rss,user,state,command
	fmt.Print("  PID  PPID STIME     TIME    RSS USER            S COMMAND\n")

	for _, pid := range pids.List {
		state := gosigar.ProcState{}
		mem := gosigar.ProcMem{}
		time := gosigar.ProcTime{}
		args := gosigar.ProcArgs{}

		if err := state.Get(pid); err != nil {
			continue
		}
		if err := mem.Get(pid); err != nil {
			continue
		}
		if err := time.Get(pid); err != nil {
			continue
		}
		if err := args.Get(pid); err != nil {
			continue
		}

		fmt.Printf("%5d %5d %s %s %6d %-15s %c %s\n",
			pid, state.Ppid,
			time.FormatStartTime(), time.FormatTotal(),
			mem.Resident/1024, state.Username, state.State,
			strings.Join(args.List, " "))
	}
}

func TestProcStateUsername(t *testing.T) {
	proc := sigar.ProcState{}
	err := proc.Get(os.Getpid())
	if err != nil {
		t.Fatal(err)
	}

	user, err := user.Current()
	if err != nil {
		t.Fatal(err)
	}

	if user.Username != proc.Username {
		t.Fatalf("Usernames don't match, expected %s, but got %s",
			user.Username, proc.Username)
	}
}

func GetProcess(pid int) (*Process, error) {

	state := sigar.ProcState{}
	mem := sigar.ProcMem{}
	cpu := sigar.ProcTime{}
	args := sigar.ProcArgs{}

	err := state.Get(pid)
	if err != nil {
		return nil, fmt.Errorf("Error getting state info: %v", err)
	}

	err = mem.Get(pid)
	if err != nil {
		return nil, fmt.Errorf("Error getting mem info: %v", err)
	}

	err = cpu.Get(pid)
	if err != nil {
		return nil, fmt.Errorf("Error getting cpu info: %v", err)
	}

	err = args.Get(pid)
	if err != nil {
		return nil, fmt.Errorf("Error getting command line: %v", err)
	}

	cmdLine := strings.Join(args.List, " ")

	proc := Process{
		Pid:      pid,
		Ppid:     state.Ppid,
		Name:     state.Name,
		State:    getProcState(byte(state.State)),
		Username: state.Username,
		CmdLine:  cmdLine,
		Mem:      mem,
		Cpu:      cpu,
	}
	proc.ctime = time.Now()

	return &proc, nil
}

func TestLinuxProcState(t *testing.T) {
	setUp(t)
	defer tearDown(t)

	var procNames = []string{
		"cron",
		"a very long process name",
	}

	for _, n := range procNames {
		func() {
			pid := rand.Int()
			pidDir := filepath.Join(procd, strconv.Itoa(pid))
			err := os.Mkdir(pidDir, 0755)
			if err != nil {
				t.Fatal(err)
			}
			defer os.RemoveAll(pidDir)
			pidStatFile := filepath.Join(pidDir, "stat")
			writePidStats(pid, n, pidStatFile)
			if err != nil {
				t.Fatal(err)
			}

			pidStatusFile := filepath.Join(pidDir, "status")
			uid := 123456789
			writePidStatus(n, pid, uid, pidStatusFile)
			if err != nil {
				t.Fatal(err)
			}

			state := sigar.ProcState{}
			if assert.NoError(t, state.Get(pid)) {
				assert.Equal(t, n, state.Name)
				assert.Equal(t, 2, state.Pgid)
				assert.Equal(t, strconv.Itoa(uid), state.Username)
			}
		}()
	}
}

func TestDarwinProcState(t *testing.T) {
	setUp(t)
	defer tearDown(t)

	state := sigar.ProcState{}
	usr, err := user.Current()
	if err == nil && usr.Username == "root" {
		if assert.NoError(t, state.Get(1)) {

			ppid, _ := strconv.Atoi(procinfo["ppid"])
			pgid, _ := strconv.Atoi(procinfo["pgid"])

			assert.Equal(t, procinfo["name"], state.Name)
			assert.Equal(t, ppid, state.Ppid)
			assert.Equal(t, pgid, state.Pgid)
			assert.Equal(t, 1, state.Pgid)
			assert.Equal(t, 0, state.Ppid)
		}
	} else {
		fmt.Println("Skipping ProcState test; run as root to test")
	}
}

func GetProcess(pid int, cmdline string) (*Process, error) {
	state := sigar.ProcState{}
	if err := state.Get(pid); err != nil {
		return nil, fmt.Errorf("error getting process state for pid=%d: %v", pid, err)
	}

	mem := sigar.ProcMem{}
	if err := mem.Get(pid); err != nil {
		return nil, fmt.Errorf("error getting process mem for pid=%d: %v", pid, err)
	}

	cpu := sigar.ProcTime{}
	if err := cpu.Get(pid); err != nil {
		return nil, fmt.Errorf("error getting process cpu time for pid=%d: %v", pid, err)
	}

	if cmdline == "" {
		args := sigar.ProcArgs{}
		if err := args.Get(pid); err != nil {
			return nil, fmt.Errorf("error getting process arguments for pid=%d: %v", pid, err)
		}
		cmdline = strings.Join(args.List, " ")
	}

	proc := Process{
		Pid:      pid,
		Ppid:     state.Ppid,
		Name:     state.Name,
		State:    getProcState(byte(state.State)),
		Username: state.Username,
		CmdLine:  cmdline,
		Mem:      mem,
		Cpu:      cpu,
		ctime:    time.Now(),
	}

	return &proc, nil
}

			pidStatFile string
			state       sigar.ProcState
		)

		BeforeEach(func() {
			pid = rand.Int()
			pidDir = filepath.Join(procd, strconv.Itoa(pid))
			err := os.Mkdir(pidDir, 0755)
			Expect(err).ToNot(HaveOccurred())
			pidStatFile = filepath.Join(pidDir, "stat")
			state = sigar.ProcState{}
		})

		It("Knows the process name", func() {
			writePidStats(pid, "cron", pidStatFile)
			state.Get(pid)
			Expect(state.Name).To(Equal("cron"))
		})

		It("Can handle spaces in the process name", func() {
			writePidStats(pid, "a very long process name", pidStatFile)
			state.Get(pid)
			Expect(state.Name).To(Equal("a very long process name"))
		})
	})

	Describe("CPU", func() {
		var (
			statFile string
			cpu      sigar.Cpu
		)

	})

	Describe("Disk", func() {
		It("gets the total disk space", func() {
			usage := sigar.FileSystemUsage{}
			err := usage.Get(os.TempDir())

			Ω(err).ShouldNot(HaveOccurred())
			Ω(usage.Total).Should(BeNumerically(">", 0))
		})
	})

	Describe("Process", func() {
		It("gets the current process user name", func() {
			proc := sigar.ProcState{}
			err := proc.Get(os.Getpid())
			user, usererr := user.Current()

			Ω(err).ShouldNot(HaveOccurred())
			Ω(usererr).ShouldNot(HaveOccurred())
			Ω(proc.Username).Should(Equal(user.Username))
		})
	})
})

func TestProcArgs(t *testing.T) {
	args := sigar.ProcArgs{}
	err := args.Get(os.Getpid())
	if err != nil {
		t.Fatal(err)
	}