--- /dev/null
+#!/usr/bin/env python
+
+import os, sys
+import subprocess
+import threading
+import Queue
+import time
+import shlex
+
+from signal import signal, SIGTERM, SIGINT, SIGPIPE, SIG_DFL
+
+SESSIOND_BIN_NAME = "lttng-sessiond"
+SESSIOND_BIN_PATH = "src/bin/lttng-sessiond/"
+CONSUMERD_BIN_NAME = "lttng-consumerd"
+CONSUMERD_BIN_PATH = "src/bin/lttng-consumerd/"
+TESTDIR_PATH = ""
+
+PRINT_BRACKET = "\033[1;34m[\033[1;33m+\033[1;34m]\033[00m"
+PRINT_RED_BRACKET = "\033[1;31m[+]\033[00m"
+PRINT_GREEN_BRACKET = "\033[1;32m[+]\033[00m"
+PRINT_ARROW = "\033[1;32m-->\033[00m"
+
+is_root = 1
+no_stats = 0
+stop_sampling = 1
+
+top_cpu_legend = { 'us': "User CPU time", 'sy': "System CPU time",
+ 'id': "Idle CPU time", 'ni': "Nice CPU time", 'wa': "iowait",
+ 'hi': "Hardware IRQ", 'si': "Software Interrupts", 'st': "Steal Time", }
+
+cpu_ret_q = Queue.Queue()
+mem_ret_q = Queue.Queue()
+test_ret_q = Queue.Queue()
+
+global sdaemon_proc
+global worker_proc
+
+def cpu_create_usage_dict(top_line):
+ """
+ Return a dictionnary from a 'top' cpu line.
+ Ex: Cpu(s): 2.1%us, 1.2%sy, 0.0%ni, 96.2%id, 0.4%wa, 0.0%hi, 0.0%si, 0.0%st
+ """
+ top_dict = {'us': 0, 'sy': 0, 'ni': 0, 'id': 0, 'wa': 0, 'hi': 0, 'si': 0, 'st': 0}
+
+ # Split expression and remove first value which is "Cpu(s)"
+ top_line = top_line.replace(",","")
+ words = top_line.split()[1:]
+
+
+ for key in top_dict:
+ index = words.index(key)
+ # Add the value to the dictionnary
+ val = words[index-1]
+ top_dict[key] = float(val)
+
+ return top_dict
+
+def cpu_average_usage(top_lines):
+ """
+ Return a dictionnary of 'top' CPU stats but averaging all values.
+ """
+ avg_dict = {'us': 0, 'sy': 0, 'ni': 0, 'id': 0, 'wa': 0, 'hi': 0, 'si': 0, 'st': 0}
+ # Average count
+ count = 0.0
+
+ for line in top_lines:
+ tmp_dict = cpu_create_usage_dict(line)
+ # Add value to avg dictionnary
+ for key in tmp_dict:
+ avg_dict[key] += tmp_dict[key]
+
+ count += 1.0
+
+ for key in avg_dict:
+ avg_dict[key] = avg_dict[key] / count
+
+ return (count, avg_dict)
+
+def cpu_sample_usage(pid=None):
+ """
+ Sample CPU usage for num iterations.
+ If num is greater than 1, the average will be computed.
+ """
+ args = ["top", "-b", "-n", "1"]
+ if pid:
+ args.append("-p")
+ args.append(str(pid))
+
+ # Spawn top process
+ top = subprocess.Popen(args, stdout = subprocess.PIPE)
+
+ grep = subprocess.Popen(["grep", "Cpu"], stdin = top.stdout,
+ stdout = subprocess.PIPE)
+ top.stdout.close()
+
+ return grep.communicate()[0].strip("\n")
+
+def mem_sample_usage(pid):
+ """
+ Sample memory usage using /proc and a pid
+ """
+ args = ["cat", "/proc/" + str(pid) + "/status"]
+
+ if not os.path.isfile(args[1]):
+ return -1
+
+ mem_proc = subprocess.Popen(args, stdout = subprocess.PIPE)
+
+ grep = subprocess.Popen(["grep", "^VmRSS"], stdin = mem_proc.stdout,
+ stdout = subprocess.PIPE)
+ mem_proc.stdout.close()
+
+ # Return virtual memory size in kilobytes (kB)
+ #ret = grep.communicate()[0].split()
+ ret = grep.communicate()[0].split()
+
+ if len(ret) > 1:
+ ret = ret[1]
+ else:
+ ret = 0
+
+ return int(ret)
+
+class SamplingWorker(threading.Thread):
+ def __init__(self, s_type, worker = None, delay = 0.2, pid = 0):
+ threading.Thread.__init__ (self)
+ self.s_type = s_type
+ self.delay = delay
+ self.pid = pid
+ self.worker = worker
+
+ def run(self):
+ count = 1
+ lines = []
+
+ if self.s_type == "cpu":
+ while 1:
+ if self.worker == None:
+ cpu_line = cpu_sample_usage(self.pid)
+ lines.append(cpu_line)
+ break
+ elif self.worker.is_alive():
+ cpu_line = cpu_sample_usage(self.pid)
+ lines.append(cpu_line)
+ else:
+ break
+
+ # Delay sec per memory sampling
+ time.sleep(self.delay)
+
+ count, stats = cpu_average_usage(lines)
+ cpu_ret_q.put((count, stats))
+ # grep process has ended here
+
+ elif self.s_type == "mem":
+ count = 0
+ mem_stat = 0
+
+ while 1:
+ if self.worker == None:
+ cpu_line = cpu_sample_usage(self.pid)
+ lines.append(cpu_line)
+ break
+ elif self.worker.is_alive():
+ mem_stat += get_mem_usage(self.pid)
+ count += 1
+ else:
+ break
+
+ # Delay sec per memory sampling
+ time.sleep(self.delay)
+
+ mem_ret_q.put((count, mem_stat))
+
+class TestWorker(threading.Thread):
+ def __init__(self, path, name, env):
+ threading.Thread.__init__(self)
+ self.path = path
+ self.name = name
+ self.env = env
+
+ def run(self):
+ bin_path_name = os.path.join(self.path, self.name)
+
+ test = subprocess.Popen([bin_path_name], env=self.env, preexec_fn = lambda: signal(SIGPIPE, SIG_DFL))
+ test.wait()
+
+ # Send ret value to main thread
+ test_ret_q.put(test.returncode)
+
+def get_pid(procname):
+ """
+ Return pid of process name using 'pidof' command
+ """
+ pidof = subprocess.Popen(["pidof", procname], stdout = subprocess.PIPE)
+ pid = pidof.communicate()[0].split()
+
+ if pid == []:
+ return 0
+
+ return int(pid[0])
+
+def spawn_session_daemon():
+ """
+ Exec the session daemon and return PID
+ """
+ global sdaemon_proc
+
+ pid = get_pid(SESSIOND_BIN_NAME)
+ if pid != 0:
+ os.kill(pid, SIGTERM)
+
+ bin_path = os.path.join(TESTDIR_PATH, "..", SESSIOND_BIN_PATH, SESSIOND_BIN_NAME)
+ consumer_path = os.path.join(TESTDIR_PATH, "..", CONSUMERD_BIN_PATH, CONSUMERD_BIN_NAME)
+
+ if not os.path.isfile(bin_path):
+ print "Error: No session daemon binary found. Compiled?"
+ return 0
+
+ try:
+ args = shlex.split("libtool execute " + bin_path
+ + " --consumerd32-path=" + consumer_path
+ + " --consumerd64-path=" + consumer_path)
+
+ sdaemon_proc = subprocess.Popen(args, shell = False, stderr = subprocess.PIPE)
+
+ except OSError, e:
+ print e
+ return 0
+
+ time.sleep(1)
+
+ return get_pid("lt-" + SESSIOND_BIN_NAME)
+
+def start_test(name):
+ """
+ Spawn test and return exit code
+ """
+ tw = TestWorker(".", name)
+ tw.start()
+
+ return test_ret_q.get(True)
+
+def print_cpu_stats(stats, count):
+ """
+ Pretty print on one line the CPU stats
+ """
+ sys.stdout.write(PRINT_ARROW + " Cpu [sampled %d time(s)]:\n " % (count))
+ for stat in stats:
+ sys.stdout.write(" %s: %.2f, " % (stat, stats[stat]))
+ print ""
+
+def get_cpu_usage(delay=1, pid=0):
+ """
+ Spawn a worker thread to sample cpu usage.
+ """
+ sw = SamplingWorker("cpu", delay = delay, pid = pid)
+ sw.start()
+
+ return cpu_ret_q.get(True)
+
+def get_mem_usage(pid):
+ """
+ Get memory usage for PID
+ """
+ return mem_sample_usage(pid)
+
+def print_test_success(ret, expect):
+ """
+ Print if test has failed or pass according to the expected value.
+ """
+ if ret != expect:
+ print "\n" + PRINT_RED_BRACKET + \
+ " Failed: ret = %d (expected %d)" % (ret, expect)
+ return 1
+ else:
+ print "\n" + PRINT_BRACKET + \
+ " Passed: ret = %d (expected %d)" % (ret, expect)
+ return 0
+
+def run_test(test):
+ """
+ Run test 'name' and output report of the test with stats.
+ """
+ global worker_proc
+ global sdaemon_proc
+ dem_pid = 0 # Session daemon pid
+
+ print PRINT_BRACKET + " %s" % (test['name'])
+ print PRINT_ARROW + " %s" % (test['desc'])
+ if no_stats:
+ print PRINT_ARROW + " Statistics will NOT be collected"
+ else:
+ print PRINT_ARROW + " Statistics of the session daemon will be collected"
+
+ if test['kern'] and not is_root:
+ print "Needs root for kernel tracing. Skipping"
+ return 0
+
+ if not os.path.isfile(test['bin']):
+ print "Unable to find test file '%s'. Skipping" % (test['bin'])
+ return 0
+
+ # Session daemon is controlled by the test
+ if test['daemon'] == "test":
+ print PRINT_ARROW + " Session daemon is controlled by the test"
+ env = os.environ
+ env['TEST_NO_SESSIOND'] = '0'
+ tw = TestWorker(".", test['bin'], env)
+ tw.start()
+ ret = test_ret_q.get(True)
+ print_test_success(ret, test['success'])
+ return 0
+ elif test['daemon'] == False:
+ print PRINT_ARROW + " No session daemon needed"
+ env = os.environ
+ env['TEST_NO_SESSIOND'] = '1'
+ tw = TestWorker(".", test['bin'], env)
+ tw.start()
+ ret = test_ret_q.get(True)
+ print_test_success(ret, test['success'])
+ return 0
+ else:
+ print PRINT_ARROW + " Session daemon needed"
+
+ dem_pid = spawn_session_daemon()
+ if dem_pid <= 0:
+ print "Unable to start %s. Stopping" % (SESSIOND_BIN_NAME)
+ print sdaemon_proc.communicate()[1]
+ return 0
+
+ print PRINT_BRACKET + " Session daemon spawned (pid: %d)\n" % (dem_pid)
+
+ if not no_stats:
+ mem_before = get_mem_usage(dem_pid)
+ print PRINT_BRACKET + " Stats *before* test:"
+ print PRINT_ARROW + " Mem (kB): %d" % (mem_before)
+ cpu_count, cpu_stats = get_cpu_usage(pid = dem_pid)
+ print_cpu_stats(cpu_stats, cpu_count)
+
+ # Sessiond was already spawned, do not let the test spawn
+ # an additional sessiond
+ env = os.environ
+ env['TEST_NO_SESSIOND'] = '1'
+
+ tw = TestWorker(".", test['bin'], env)
+ tw.start()
+
+ if not no_stats:
+ # Start CPU sampling for test
+ sw_cpu = SamplingWorker("cpu", worker = tw, pid = dem_pid)
+ sw_cpu.start()
+ sw_mem = SamplingWorker("mem", worker = tw, pid = dem_pid)
+ sw_mem.start()
+
+ ret = test_ret_q.get(True)
+
+ if not no_stats:
+ time.sleep(2)
+ # Compute memory average
+ mem_count, mem_during = mem_ret_q.get(True)
+ mem_during = float(mem_during) / float(mem_count)
+ cpu_count, cpu_stats = cpu_ret_q.get(True)
+
+ print "\n" + PRINT_BRACKET + " Stats *during* test:"
+ print PRINT_ARROW + " Mem (kB): %.0f [sampled %d time(s)]" % (mem_during, mem_count)
+ print_cpu_stats(cpu_stats, cpu_count)
+
+ mem_after = get_mem_usage(dem_pid)
+ print "\n" + PRINT_BRACKET + " Stats *after* test:"
+ print PRINT_ARROW + " Mem (kB): %d" % (mem_after)
+ cpu_count, cpu_stats = get_cpu_usage(pid = dem_pid)
+ print_cpu_stats(cpu_stats, cpu_count)
+
+ print "\n" + PRINT_BRACKET + " Memory usage differences:"
+ print PRINT_ARROW + " Diff during and before (kB): %d" % (mem_during - mem_before)
+ print PRINT_ARROW + " Diff during and after (kB): %d" % (mem_during - mem_after)
+ print PRINT_ARROW + " Diff before and after (kB): %d" % (mem_after - mem_before)
+
+ # Return value of 0 means that is passed else it failed
+ ret = print_test_success(ret, test['success'])
+
+ # Stop session daemon
+ if dem_pid > 0:
+ print PRINT_BRACKET + " Stopping session daemon (pid: %d)..." % (dem_pid)
+ try:
+ os.kill(dem_pid, SIGTERM)
+ # This call simply does not work... It seems python does not relay the signal
+ # to the child processes of sdaemon_proc.
+ # sdaemon_proc.terminate()
+ if ret != 0:
+ print sdaemon_proc.communicate()[1]
+ elif sdaemon_proc.returncode == None:
+ sdaemon_proc.communicate()
+ except OSError, e:
+ print e
+
+ # Make sure all thread are released
+ if not no_stats:
+ tw.join()
+ sw_cpu.join()
+ sw_mem.join()
+
+ return ret
+
+def main():
+ for test in Tests:
+ if not test['enabled']:
+ continue
+
+ ret = run_test(test)
+ if ret != 0:
+ # Stop all tests, the last one failed
+ return
+ print ""
+
+def cleanup(signo, stack):
+ """ Cleanup function """
+ sys.exit(0)
+
+if __name__ == "__main__":
+ if not os.getuid() == 0:
+ is_root = 0
+ print "NOTICE: Not root. No kernel tracing will be tested\n"
+
+ if os.path.isfile("test_list.py"):
+ from test_list import Tests
+ else:
+ print "No test_list.py found. Stopping"
+ cleanup(0, 0)
+
+ TESTDIR_PATH = os.getcwd()
+
+ if len(sys.argv) > 1:
+ if sys.argv[1] == "--no-stats":
+ no_stats = 1
+
+ try:
+ signal(SIGTERM, cleanup)
+ signal(SIGINT, cleanup)
+ main()
+ cleanup(0, 0)
+ except KeyboardInterrupt:
+ cleanup(0, 0)
projects / lttng-tools.git / blobdiff