pkg.re/essentialkaos/ek@v12.36.0+incompatible/system/process/process_test.go (about)

     1  // +build linux
     2  
     3  package process
     4  
     5  // ////////////////////////////////////////////////////////////////////////////////// //
     6  //                                                                                    //
     7  //                         Copyright (c) 2021 ESSENTIAL KAOS                          //
     8  //      Apache License, Version 2.0 <https://www.apache.org/licenses/LICENSE-2.0>     //
     9  //                                                                                    //
    10  // ////////////////////////////////////////////////////////////////////////////////// //
    11  
    12  import (
    13  	"io/ioutil"
    14  	"os"
    15  	"testing"
    16  	"time"
    17  
    18  	. "pkg.re/essentialkaos/check.v1"
    19  )
    20  
    21  // ////////////////////////////////////////////////////////////////////////////////// //
    22  
    23  func Test(t *testing.T) { TestingT(t) }
    24  
    25  type ProcessSuite struct{}
    26  
    27  // ////////////////////////////////////////////////////////////////////////////////// //
    28  
    29  var _ = Suite(&ProcessSuite{})
    30  
    31  // ////////////////////////////////////////////////////////////////////////////////// //
    32  
    33  func (s *ProcessSuite) TestGetTree(c *C) {
    34  	tree, err := GetTree(66000)
    35  
    36  	c.Assert(err, NotNil)
    37  	c.Assert(tree, IsNil)
    38  
    39  	tree, err = GetTree(os.Getpid())
    40  
    41  	c.Assert(err, IsNil)
    42  	c.Assert(tree, NotNil)
    43  
    44  	procFS = s.CreateFakeProcFS(c, "10000", "task", "AABBCC")
    45  
    46  	_, err = GetTree(10000)
    47  	c.Assert(err, NotNil)
    48  
    49  	procFS = "/proc"
    50  }
    51  
    52  func (s *ProcessSuite) TestGetTreeAux(c *C) {
    53  	_, err := readProcessInfo("/_UNKNOWN_", "ABCD", map[int]string{})
    54  	c.Assert(err, NotNil)
    55  
    56  	c.Assert(isPID(""), Equals, false)
    57  
    58  	_, err = getProcessUser(9999, map[int]string{})
    59  	c.Assert(err, NotNil)
    60  
    61  	p1, p2 := getParentPIDs("/_UNKNOWN_")
    62  	c.Assert(p1, Equals, -1)
    63  	c.Assert(p2, Equals, -1)
    64  
    65  	processListToTree([]*ProcessInfo{
    66  		&ProcessInfo{Parent: -1},
    67  	}, 0)
    68  
    69  	pidDir := s.CreateFakeProcFS(c, "10000", "status", "Tgid: \nPPid: \n")
    70  
    71  	tree, err := readProcessInfo(pidDir, "10000", map[int]string{})
    72  	c.Assert(tree, IsNil)
    73  	c.Assert(err, IsNil)
    74  
    75  	p1, p2 = getParentPIDs(pidDir + "/10000")
    76  	c.Assert(p1, Equals, -1)
    77  	c.Assert(p2, Equals, -1)
    78  
    79  	pidDir = s.CreateFakeProcFS(c, "10000", "status", "Tgid: X\nPPid: X\n")
    80  
    81  	p1, p2 = getParentPIDs(pidDir + "/10000")
    82  	c.Assert(p1, Equals, -1)
    83  	c.Assert(p2, Equals, -1)
    84  }
    85  
    86  func (s *ProcessSuite) TestGetList(c *C) {
    87  	procs, err := GetList()
    88  
    89  	c.Assert(err, IsNil)
    90  	c.Assert(procs, NotNil)
    91  	c.Assert(procs, Not(HasLen), 0)
    92  }
    93  
    94  func (s *ProcessSuite) TestGetInfo(c *C) {
    95  	info, err := GetInfo(66000)
    96  
    97  	c.Assert(err, NotNil)
    98  	c.Assert(info, IsNil)
    99  
   100  	info, err = GetInfo(1)
   101  
   102  	c.Assert(err, IsNil)
   103  	c.Assert(info, NotNil)
   104  
   105  	procFS = s.CreateFakeProcFS(c, "10000", "stat", "AABBCC")
   106  
   107  	info, err = GetInfo(10000)
   108  	c.Assert(err, NotNil)
   109  	c.Assert(info, IsNil)
   110  
   111  	procFS = "/proc"
   112  
   113  	_, err = parseStatData("AA BB CC")
   114  	c.Assert(err, NotNil)
   115  
   116  	_, err = parseSampleData("0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 0")
   117  	c.Assert(err, NotNil)
   118  }
   119  
   120  func (s *ProcessSuite) TestGetSample(c *C) {
   121  	_, err := GetSample(66000)
   122  
   123  	c.Assert(err, NotNil)
   124  
   125  	_, err = GetSample(1)
   126  
   127  	c.Assert(err, IsNil)
   128  
   129  	procFS = s.CreateFakeProcFS(c, "10000", "stat", "AABBCC")
   130  
   131  	_, err = GetSample(10000)
   132  	c.Assert(err, NotNil)
   133  
   134  	procFS = "/proc"
   135  }
   136  
   137  func (s *ProcessSuite) TestInfoToSample(c *C) {
   138  	pi := &ProcInfo{UTime: 10, STime: 1, CUTime: 1, CSTime: 1}
   139  	ps := pi.ToSample()
   140  
   141  	c.Assert(ps, Equals, ProcSample(13))
   142  }
   143  
   144  func (s *ProcessSuite) TestGetMemInfo(c *C) {
   145  	info, err := GetMemInfo(66000)
   146  
   147  	c.Assert(err, NotNil)
   148  	c.Assert(info, IsNil)
   149  
   150  	info, err = GetMemInfo(1)
   151  
   152  	c.Assert(err, IsNil)
   153  	c.Assert(info, NotNil)
   154  
   155  	procFS = s.CreateFakeProcFS(c, "10000", "status", "VmPeak: AAA")
   156  
   157  	info, err = GetMemInfo(10000)
   158  	c.Assert(err, NotNil)
   159  	c.Assert(info, IsNil)
   160  
   161  	procFS = s.CreateFakeProcFS(c, "10000", "status", "VmPeak:         0 kB\nVmSize:         0 kB\n")
   162  
   163  	info, err = GetMemInfo(10000)
   164  	c.Assert(err, NotNil)
   165  	c.Assert(info, IsNil)
   166  
   167  	procFS = "/proc"
   168  }
   169  
   170  func (s *ProcessSuite) TestGetMountInfo(c *C) {
   171  	info, err := GetMountInfo(66000)
   172  
   173  	c.Assert(err, NotNil)
   174  	c.Assert(info, IsNil)
   175  
   176  	info, err = GetMountInfo(1)
   177  
   178  	c.Assert(err, IsNil)
   179  	c.Assert(info, NotNil)
   180  
   181  	_, _, err = parseStDevValue("AA:11")
   182  	c.Assert(err, NotNil)
   183  
   184  	_, _, err = parseStDevValue("11:AA")
   185  	c.Assert(err, NotNil)
   186  
   187  	_, err = parseMountInfoLine("AA AA")
   188  	c.Assert(err, NotNil)
   189  
   190  	procFS = s.CreateFakeProcFS(c, "10000", "mountinfo", "AA AA AA")
   191  
   192  	info, err = GetMountInfo(10000)
   193  
   194  	c.Assert(err, NotNil)
   195  	c.Assert(info, IsNil)
   196  
   197  	procFS = "/proc"
   198  }
   199  
   200  func (s *ProcessSuite) TestCalculateCPUUsage(c *C) {
   201  	s1 := ProcSample(13)
   202  	s2 := ProcSample(66)
   203  
   204  	c.Assert(CalculateCPUUsage(s1, s2, time.Second), Equals, 53.0)
   205  }
   206  
   207  func (s *ProcessSuite) TestCPUPriority(c *C) {
   208  	pid := os.Getpid()
   209  
   210  	pri, ni, err := GetCPUPriority(pid)
   211  	c.Assert(err, IsNil)
   212  	c.Assert(pri, Equals, 20)
   213  	c.Assert(ni, Equals, 0)
   214  
   215  	err = SetCPUPriority(pid, 2)
   216  	c.Assert(err, IsNil)
   217  
   218  	pri, ni, err = GetCPUPriority(pid)
   219  	c.Assert(err, IsNil)
   220  	c.Assert(pri, Equals, 22)
   221  	c.Assert(ni, Equals, 2)
   222  
   223  	_, _, err = GetCPUPriority(12000000)
   224  	c.Assert(err, NotNil)
   225  }
   226  
   227  func (s *ProcessSuite) TestIOPriority(c *C) {
   228  	pid := os.Getpid()
   229  
   230  	class, classdata, err := GetIOPriority(pid)
   231  	c.Assert(err, IsNil)
   232  	c.Assert(class, Equals, PRIO_CLASS_NONE)
   233  	c.Assert(classdata, Equals, 4)
   234  
   235  	err = SetIOPriority(pid, PRIO_CLASS_BEST_EFFORT, 5)
   236  	c.Assert(err, IsNil)
   237  
   238  	class, classdata, err = GetIOPriority(pid)
   239  	c.Assert(err, IsNil)
   240  	c.Assert(class, Equals, PRIO_CLASS_BEST_EFFORT)
   241  	c.Assert(classdata, Equals, 5)
   242  
   243  	_, _, err = GetIOPriority(999999)
   244  	c.Assert(err, NotNil)
   245  
   246  	err = SetIOPriority(999999, PRIO_CLASS_BEST_EFFORT, 5)
   247  	c.Assert(err, NotNil)
   248  }
   249  
   250  // ////////////////////////////////////////////////////////////////////////////////// //
   251  
   252  func (s *ProcessSuite) CreateFakeProcFS(c *C, pid, file, data string) string {
   253  	tmpDir := c.MkDir()
   254  	os.Mkdir(tmpDir+"/"+pid, 0755)
   255  	pfsFile := tmpDir + "/" + pid + "/" + file
   256  
   257  	if ioutil.WriteFile(pfsFile, []byte(data), 0644) != nil {
   258  		c.Fatal("Can't create temporary file")
   259  	}
   260  
   261  	return tmpDir
   262  }