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

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