def send_init_info(self):
# system_cpu_info
mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
sys_cpu = SystemCpuInfo()
sys_cpu.num_socket = mem_cpu_usage_data.get_num_socket()
sys_cpu.num_cpu = mem_cpu_usage_data.get_num_cpu()
sys_cpu.num_core_per_socket = mem_cpu_usage_data.get_num_core_per_socket()
sys_cpu.num_thread_per_core = mem_cpu_usage_data.get_num_thread_per_core()
node_status = NodeStatus(
name=socket.gethostname(),
system_cpu_info=sys_cpu,
build_info = self.get_build_info())
# installed/running package version
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
sys.stderr.write("Error getting %s package version\n"
% (self.get_package_name()))
exit(-1)
else:
self.installed_package_version = installed_package_version
node_status.installed_package_version = installed_package_version
node_status.running_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.table,
data=node_status)
node_status_uve.send()
def send_init_info(self, group_name):
key = next(key for key in self.process_state_db[group_name])
# system_cpu_info
mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
sys_cpu = SystemCpuInfo()
sys_cpu.num_socket = mem_cpu_usage_data.get_num_socket()
sys_cpu.num_cpu = mem_cpu_usage_data.get_num_cpu()
sys_cpu.num_core_per_socket = mem_cpu_usage_data.get_num_core_per_socket()
sys_cpu.num_thread_per_core = mem_cpu_usage_data.get_num_thread_per_core()
node_status = NodeStatus(
name=self.process_state_db[group_name][key].name,
system_cpu_info=sys_cpu,
build_info = self.get_build_info())
# installed/running package version
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
self.msg_log('Error getting %s package version' % (self.get_package_name()),
SandeshLevel.SYS_ERR)
exit(-1)
else:
self.installed_package_version = installed_package_version
node_status.installed_package_version = installed_package_version
node_status.running_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.type_info._object_table,
data=node_status)
node_status_uve.send()
def get_system_mem_cpu_usage(self):
system_mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu,
self.last_time)
system_mem_cpu_usage = system_mem_cpu_usage_data.get_sys_mem_cpu_info()
self.last_cpu = system_mem_cpu_usage_data.last_cpu
self.last_time = system_mem_cpu_usage_data.last_time
return system_mem_cpu_usage
def get_all_processes_mem_cpu_usage(self):
process_mem_cpu_usage = {}
for key in self.process_state_db:
pstat = self.process_state_db[key]
if (pstat.process_state == 'PROCESS_STATE_RUNNING'):
try:
mem_cpu_usage_data = MemCpuUsageData(pstat.pid)
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info()
except psutil.NoSuchProcess:
sys.stderr.write("NoSuchProcess: process name:%s pid:%d\n"
% (pstat.pname, pstat.pid))
else:
process_mem_cpu.__key = pstat.pname
process_mem_cpu_usage[process_mem_cpu.__key] = process_mem_cpu
# walk through all processes being monitored by nodemgr,
# not spawned by supervisord
third_party_process_list = self.get_node_third_party_process_list()
for pname in third_party_process_list:
cmd = "ps -aux | grep -v grep | grep " + str(pname) + " | awk '{print $2}' | head -n1"
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = proc.communicate()
if (stdout != ''):
pid = int(stdout.strip('\n'))
try:
mem_cpu_usage_data = MemCpuUsageData(pid)
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info()
except psutil.NoSuchProcess:
sys.stderr.write("NoSuchProcess: process name:%s pid:%d\n"
% (pname, pid))
else:
process_mem_cpu.__key = pname
process_mem_cpu_usage[process_mem_cpu.__key] = process_mem_cpu
return process_mem_cpu_usage
def send_system_cpu_info(self):
mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
sys_cpu = SystemCpuInfo()
sys_cpu.num_socket = mem_cpu_usage_data.get_num_socket()
sys_cpu.num_cpu = mem_cpu_usage_data.get_num_cpu()
sys_cpu.num_core_per_socket = mem_cpu_usage_data.get_num_core_per_socket()
sys_cpu.num_thread_per_core = mem_cpu_usage_data.get_num_thread_per_core()
node_status = NodeStatus(name=socket.gethostname(), system_cpu_info=sys_cpu)
node_status_uve = NodeStatusUVE(table=self.table, data=node_status)
node_status_uve.send()
def event_tick_60(self):
self.tick_count += 1
for group in self.process_state_db:
key = next(key for key in self.process_state_db[group])
# get disk usage info periodically
disk_usage_info = self.get_disk_usage()
# typical ntp sync time is about 5 min - first time,
# we scan only after 10 min
if self.tick_count >= 10:
self.check_ntp_status()
if self.update_process_core_file_list():
self.send_process_state_db([group])
process_mem_cpu_usage = self.get_group_processes_mem_cpu_usage(
group)
# get system mem/cpu usage
system_mem_cpu_usage_data = MemCpuUsageData(
os.getpid(), self.last_cpu, self.last_time)
system_mem_usage = system_mem_cpu_usage_data.get_sys_mem_info(
self.type_info._uve_node_type)
system_cpu_usage = system_mem_cpu_usage_data.get_sys_cpu_info(
self.type_info._uve_node_type)
# update last_cpu/time after all processing is complete
self.last_cpu = system_mem_cpu_usage_data.last_cpu
self.last_time = system_mem_cpu_usage_data.last_time
# send above encoded buffer
node_status = NodeStatus(
name=self.process_state_db[group][key].name,
disk_usage_info=disk_usage_info,
system_mem_usage=system_mem_usage,
system_cpu_usage=system_cpu_usage,
process_mem_cpu_usage=process_mem_cpu_usage)
# encode other core file
if self.update_all_core_file():
node_status.all_core_file_list = self.all_core_file_list
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
self.msg_log(
'Error getting %s package version' %
(self.get_package_name()), SandeshLevel.SYS_ERR)
installed_package_version = "package-version-unknown"
if (installed_package_version != self.installed_package_version):
node_status.installed_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.type_info._object_table,
data=node_status)
node_status_uve.send()
self.installed_package_version = installed_package_version
def event_tick_60(self):
self.tick_count += 1
for group in self.process_state_db:
key = next(key for key in self.process_state_db[group])
# get disk usage info periodically
disk_usage_info = self.get_disk_usage()
# typical ntp sync time is about 5 min - first time,
# we scan only after 10 min
if self.tick_count >= 10:
self.check_ntp_status()
if self.update_process_core_file_list():
self.send_process_state_db([group])
process_mem_cpu_usage = self.get_group_processes_mem_cpu_usage(group)
# get system mem/cpu usage
system_mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
system_mem_usage = system_mem_cpu_usage_data.get_sys_mem_info(
self.type_info._uve_node_type)
system_cpu_usage = system_mem_cpu_usage_data.get_sys_cpu_info(
self.type_info._uve_node_type)
# update last_cpu/time after all processing is complete
self.last_cpu = system_mem_cpu_usage_data.last_cpu
self.last_time = system_mem_cpu_usage_data.last_time
# send above encoded buffer
node_status = NodeStatus(name=self.process_state_db[group][key].name,
disk_usage_info=disk_usage_info,
system_mem_usage=system_mem_usage,
system_cpu_usage=system_cpu_usage,
process_mem_cpu_usage=process_mem_cpu_usage)
# encode other core file
if self.update_all_core_file():
node_status.all_core_file_list = self.all_core_file_list
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
self.msg_log('Error getting %s package version' % (self.get_package_name()),
SandeshLevel.SYS_ERR)
installed_package_version = "package-version-unknown"
if (installed_package_version != self.installed_package_version):
node_status.installed_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.type_info._object_table,
data=node_status)
node_status_uve.send()
self.installed_package_version = installed_package_version
def event_tick_60(self):
self.tick_count += 1
# get disk usage info periodically
disk_usage_info = self.get_disk_usage()
# typical ntp sync time is about 5 min - first time,
# we scan only after 10 min
if self.tick_count >= 10:
self.check_ntp_status()
if self.update_process_core_file_list():
self.send_process_state_db(['default'])
process_mem_cpu_usage = self.get_all_processes_mem_cpu_usage()
# get system mem/cpu usage
system_mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu,
self.last_time)
system_mem_usage = system_mem_cpu_usage_data.get_sys_mem_info(
self.type_info._uve_node_type)
system_cpu_usage = system_mem_cpu_usage_data.get_sys_cpu_info(
self.type_info._uve_node_type)
# update last_cpu/time after all processing is complete
self.last_cpu = system_mem_cpu_usage_data.last_cpu
self.last_time = system_mem_cpu_usage_data.last_time
# send above encoded buffer
node_status = NodeStatus(name=socket.gethostname(),
disk_usage_info=disk_usage_info,
system_mem_usage=system_mem_usage,
system_cpu_usage=system_cpu_usage,
process_mem_cpu_usage=process_mem_cpu_usage)
# encode other core file
if self.update_all_core_file():
node_status.all_core_file_list = self.all_core_file_list
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
sys.stderr.write("Error getting %s package version\n" %
(self.get_package_name()))
installed_package_version = "package-version-unknown"
if (installed_package_version != self.installed_package_version):
self.installed_package_version = installed_package_version
node_status.installed_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.type_info._object_table,
data=node_status)
node_status_uve.send()
def get_group_processes_mem_cpu_usage(self, group_name):
process_mem_cpu_usage = {}
for key in self.process_state_db[group_name]:
pstat = self.process_state_db[group_name][key]
if (pstat.process_state == 'PROCESS_STATE_RUNNING'):
try:
mem_cpu_usage_data = MemCpuUsageData(pstat.pid, pstat.last_cpu, pstat.last_time)
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info()
except psutil.NoSuchProcess:
self.msg_log('NoSuchProcess: process name: %s pid:%d' % (pstat.pname, pstat.pid),
SandeshLevel.SYS_ERR)
else:
process_mem_cpu.__key = pstat.pname
process_mem_cpu_usage[process_mem_cpu.__key] = process_mem_cpu
pstat.last_cpu = mem_cpu_usage_data.last_cpu
pstat.last_time = mem_cpu_usage_data.last_time
# walk through all processes being monitored by nodemgr,
# not spawned by supervisord
for pname, pattern in self.third_party_process_dict.items():
cmd = "ps -aux | grep " + pattern + " | awk '{print $2}' | head -n1"
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, close_fds=True)
stdout, stderr = proc.communicate()
if (stdout != ''):
pid = int(stdout.strip('\n'))
if pname in self.third_party_process_state_db:
pstat = self.third_party_process_state_db[pname]
else:
pstat = self.get_process_stat_object(pname)
pstat.pid = pid
self.third_party_process_state_db[pname] = pstat
try:
mem_cpu_usage_data = MemCpuUsageData(pstat.pid, pstat.last_cpu, pstat.last_time)
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info()
except psutil.NoSuchProcess:
self.msg_log('NoSuchProcess: process name:%s pid:%d' % (pstat.pname, pstat.pid),
SandeshLevel.SYS_ERR)
self.third_party_process_state_db.pop(pstat.pname)
else:
process_mem_cpu.__key = pname
process_mem_cpu_usage[process_mem_cpu.__key] = process_mem_cpu
pstat.last_cpu = mem_cpu_usage_data.last_cpu
pstat.last_time = mem_cpu_usage_data.last_time
return process_mem_cpu_usage
def get_all_processes_mem_cpu_usage(self):
process_mem_cpu_usage = {}
for key in self.process_state_db:
pstat = self.process_state_db[key]
if pstat.process_state == "PROCESS_STATE_RUNNING":
try:
mem_cpu_usage_data = MemCpuUsageData(pstat.pid, pstat.last_cpu, pstat.last_time)
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info()
except psutil.NoSuchProcess:
sys.stderr.write("NoSuchProcess: process name:%s pid:%d\n" % (pstat.pname, pstat.pid))
else:
process_mem_cpu.__key = pstat.pname
process_mem_cpu_usage[process_mem_cpu.__key] = process_mem_cpu
pstat.last_cpu = mem_cpu_usage_data.last_cpu
pstat.last_time = mem_cpu_usage_data.last_time
# walk through all processes being monitored by nodemgr,
# not spawned by supervisord
third_party_process_dict = self.get_node_third_party_process_dict()
for pname in third_party_process_dict:
pattern = third_party_process_dict[pname]
cmd = "ps -aux | grep " + pattern + " | awk '{print $2}' | head -n1"
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = proc.communicate()
if stdout != "":
pid = int(stdout.strip("\n"))
if pname in self.third_party_process_state_db:
pstat = self.third_party_process_state_db[pname]
else:
pstat = self.get_process_stat_object(pname)
pstat.pid = pid
self.third_party_process_state_db[pname] = pstat
try:
mem_cpu_usage_data = MemCpuUsageData(pstat.pid, pstat.last_cpu, pstat.last_time)
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info()
except psutil.NoSuchProcess:
sys.stderr.write("NoSuchProcess: process name:%s pid:%d\n" % (pstat.pname, pstat.pid))
self.third_party_process_state_db.pop(pstat.pname)
else:
process_mem_cpu.__key = pname
process_mem_cpu_usage[process_mem_cpu.__key] = process_mem_cpu
pstat.last_cpu = mem_cpu_usage_data.last_cpu
pstat.last_time = mem_cpu_usage_data.last_time
return process_mem_cpu_usage
def send_init_info(self):
# system_cpu_info
mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
sys_cpu = SystemCpuInfo()
sys_cpu.num_socket = mem_cpu_usage_data.get_num_socket()
sys_cpu.num_cpu = mem_cpu_usage_data.get_num_cpu()
sys_cpu.num_core_per_socket = mem_cpu_usage_data.get_num_core_per_socket()
sys_cpu.num_thread_per_core = mem_cpu_usage_data.get_num_thread_per_core()
node_status = NodeStatus(
name=socket.gethostname(),
system_cpu_info=sys_cpu,
build_info = self.get_build_info())
# installed/running package version
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
sys.stderr.write("Error getting %s package version\n"
% (self.get_package_name()))
exit(-1)
else:
self.installed_package_version = installed_package_version
node_status.installed_package_version = installed_package_version
node_status.running_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.type_info._object_table,
data=node_status)
node_status_uve.send()
def send_init_info(self):
self.group_names = list(set([pstat.group for pstat in self.process_state_db.values()]))
for group in self.group_names:
key = next(key for key, pstat in self.process_state_db.items() if pstat.group == group)
# system_cpu_info
mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
sys_cpu = SystemCpuInfo()
sys_cpu.num_socket = mem_cpu_usage_data.get_num_socket()
sys_cpu.num_cpu = mem_cpu_usage_data.get_num_cpu()
sys_cpu.num_core_per_socket = mem_cpu_usage_data.get_num_core_per_socket()
sys_cpu.num_thread_per_core = mem_cpu_usage_data.get_num_thread_per_core()
node_status = NodeStatus(
name=self.process_state_db[key].name,
system_cpu_info=sys_cpu,
build_info = self.get_build_info())
# installed/running package version
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
sys.stderr.write("Error getting %s package version\n"
% (self.get_package_name()))
exit(-1)
else:
self.installed_package_version = installed_package_version
node_status.installed_package_version = installed_package_version
node_status.running_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.type_info._object_table,
data=node_status)
node_status_uve.send()
def send_init_info(self, group_name):
key = next(key for key in self.process_state_db[group_name])
# system_cpu_info
mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu,
self.last_time)
sys_cpu = SystemCpuInfo()
sys_cpu.num_socket = mem_cpu_usage_data.get_num_socket()
sys_cpu.num_cpu = mem_cpu_usage_data.get_num_cpu()
sys_cpu.num_core_per_socket = mem_cpu_usage_data.get_num_core_per_socket(
)
sys_cpu.num_thread_per_core = mem_cpu_usage_data.get_num_thread_per_core(
)
node_status = NodeStatus(
name=self.process_state_db[group_name][key].name,
system_cpu_info=sys_cpu,
build_info=self.get_build_info())
# installed/running package version
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
self.msg_log(
'Error getting %s package version' % (self.get_package_name()),
SandeshLevel.SYS_ERR)
exit(-1)
else:
self.installed_package_version = installed_package_version
node_status.installed_package_version = installed_package_version
node_status.running_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.type_info._object_table,
data=node_status)
node_status_uve.send()
def get_group_processes_mem_cpu_usage(self, group_name):
process_mem_cpu_usage = {}
for key in self.process_state_db:
pstat = self.process_state_db[key]
if pstat.group != group_name:
continue
if (pstat.process_state == 'PROCESS_STATE_RUNNING'):
try:
mem_cpu_usage_data = MemCpuUsageData(
pstat.pid, pstat.last_cpu, pstat.last_time)
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info(
)
except psutil.NoSuchProcess:
sys.stderr.write(
"NoSuchProcess: process name:%s pid:%d\n" %
(pstat.pname, pstat.pid))
else:
process_mem_cpu.__key = pstat.pname
process_mem_cpu_usage[
process_mem_cpu.__key] = process_mem_cpu
pstat.last_cpu = mem_cpu_usage_data.last_cpu
pstat.last_time = mem_cpu_usage_data.last_time
# walk through all processes being monitored by nodemgr,
# not spawned by supervisord
for pname, pattern in self.third_party_process_dict.items():
cmd = "ps -aux | grep " + pattern + " | awk '{print $2}' | head -n1"
proc = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
stdout, stderr = proc.communicate()
if (stdout != ''):
pid = int(stdout.strip('\n'))
if pname in self.third_party_process_state_db:
pstat = self.third_party_process_state_db[pname]
else:
pstat = self.get_process_stat_object(pname)
pstat.pid = pid
self.third_party_process_state_db[pname] = pstat
try:
mem_cpu_usage_data = MemCpuUsageData(
pstat.pid, pstat.last_cpu, pstat.last_time)
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info(
)
except psutil.NoSuchProcess:
sys.stderr.write(
"NoSuchProcess: process name:%s pid:%d\n" %
(pstat.pname, pstat.pid))
self.third_party_process_state_db.pop(pstat.pname)
else:
process_mem_cpu.__key = pname
process_mem_cpu_usage[
process_mem_cpu.__key] = process_mem_cpu
pstat.last_cpu = mem_cpu_usage_data.last_cpu
pstat.last_time = mem_cpu_usage_data.last_time
return process_mem_cpu_usage
def send_system_cpu_info(self):
mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
sys_cpu = SystemCpuInfo()
sys_cpu.num_socket = mem_cpu_usage_data.get_num_socket()
sys_cpu.num_cpu = mem_cpu_usage_data.get_num_cpu()
sys_cpu.num_core_per_socket = mem_cpu_usage_data.get_num_core_per_socket()
sys_cpu.num_thread_per_core = mem_cpu_usage_data.get_num_thread_per_core()
node_status = NodeStatus(name=socket.gethostname(),
system_cpu_info=sys_cpu)
node_status_uve = NodeStatusUVE(table=self.table,
data=node_status)
node_status_uve.send()
def get_all_processes_mem_cpu_usage(self):
process_mem_cpu_usage = []
for key in self.process_state_db:
pstat = self.process_state_db[key]
if (pstat.process_state == 'PROCESS_STATE_RUNNING'):
try:
mem_cpu_usage_data = MemCpuUsageData(pstat.pid)
except psutil.NoSuchProcess:
sys.stderr.write(
"NoSuchProcess: process name:%s pid:%d\n" %
(pstat.pname, pstat.pid))
else:
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info(
)
process_mem_cpu.module_id = pstat.pname
process_mem_cpu.inst_id = "0" # ??
process_mem_cpu_usage.append(process_mem_cpu)
# walk through all processes being monitored by nodemgr,
# not spawned by supervisord
third_party_process_list = self.get_node_third_party_process_list()
for pname in third_party_process_list:
cmd = "ps -aux | grep -v grep | grep " + str(
pname) + " | awk '{print $2}' | head -n1"
proc = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout, stderr = proc.communicate()
if (stdout != ''):
pid = int(stdout.strip('\n'))
try:
mem_cpu_usage_data = MemCpuUsageData(pid)
except psutil.NoSuchProcess:
sys.stderr.write(
"NoSuchProcess: process name:%s pid:%d\n" %
(pname, pid))
else:
process_mem_cpu = mem_cpu_usage_data.get_process_mem_cpu_info(
)
process_mem_cpu.module_id = pname
process_mem_cpu.inst_id = "0"
process_mem_cpu_usage.append(process_mem_cpu)
return process_mem_cpu_usage
def send_init_info(self):
# system_cpu_info
mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
sys_cpu = SystemCpuInfo()
sys_cpu.num_socket = mem_cpu_usage_data.get_num_socket()
sys_cpu.num_cpu = mem_cpu_usage_data.get_num_cpu()
sys_cpu.num_core_per_socket = mem_cpu_usage_data.get_num_core_per_socket()
sys_cpu.num_thread_per_core = mem_cpu_usage_data.get_num_thread_per_core()
# installed/running package version
self.installed_package_version = NodeMgrUtils.get_package_version \
(self.get_package_name())
node_status = NodeStatus(
name=socket.gethostname(),
system_cpu_info=sys_cpu,
installed_package_version=self.installed_package_version,
running_package_version=self.installed_package_version,
build_info = self.get_build_info())
node_status_uve = NodeStatusUVE(table=self.table,
data=node_status)
node_status_uve.send()
def event_tick_60(self):
self.tick_count += 1
# get disk usage info periodically
disk_usage_info = self.get_disk_usage()
# typical ntp sync time is about 5 min - first time,
# we scan only after 10 min
if self.tick_count >= 10:
self.check_ntp_status()
if self.update_process_core_file_list():
self.send_process_state_db(['default'])
process_mem_cpu_usage = self.get_all_processes_mem_cpu_usage()
# get system mem/cpu usage
system_mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
system_mem_usage = system_mem_cpu_usage_data.get_sys_mem_info(self.uve_node_type)
system_cpu_usage = system_mem_cpu_usage_data.get_sys_cpu_info(self.uve_node_type)
# update last_cpu/time after all processing is complete
self.last_cpu = system_mem_cpu_usage_data.last_cpu
self.last_time = system_mem_cpu_usage_data.last_time
# send above encoded buffer
node_status = NodeStatus(name=socket.gethostname(),
disk_usage_info=disk_usage_info,
system_mem_usage=system_mem_usage,
system_cpu_usage=system_cpu_usage,
process_mem_cpu_usage=process_mem_cpu_usage)
# encode other core file
if self.update_all_core_file():
node_status.all_core_file_list = self.all_core_file_list
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
sys.stderr.write("Error getting %s package version\n"
% (self.get_package_name()))
installed_package_version = "package-version-unknown"
if (installed_package_version != self.installed_package_version):
self.installed_package_version = installed_package_version
node_status.installed_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.table,
data=node_status)
node_status_uve.send()
current_time = int(time.time())
if ((abs(current_time - self.prev_current_time)) > 300):
# update all process start_times with the updated time
# Compute the elapsed time and subtract them from
# current time to get updated values
sys.stderr.write(
"Time lapse detected " +
str(abs(current_time - self.prev_current_time)) + "\n")
for key in self.process_state_db:
pstat = self.process_state_db[key]
if pstat.start_time is not '':
pstat.start_time = str(
(int(current_time - (self.prev_current_time -
((int)(pstat.start_time)) / 1000000))) * 1000000)
if (pstat.process_state == 'PROCESS_STATE_STOPPED'):
if pstat.stop_time is not '':
pstat.stop_time = str(
int(current_time - (self.prev_current_time -
((int)(pstat.stop_time)) / 1000000)) *
1000000)
if (pstat.process_state == 'PROCESS_STATE_EXITED'):
if pstat.exit_time is not '':
pstat.exit_time = str(
int(current_time - (self.prev_current_time -
((int)(pstat.exit_time)) / 1000000)) *
1000000)
# update process state database
self.process_state_db[key] = pstat
try:
json_file = '/var/log/contrail/process_state' + \
self.node_type + ".json"
f = open(json_file, 'w')
f.write(
json.dumps(
self.process_state_db,
default=lambda obj: obj.__dict__))
except:
sys.stderr.write("Unable to write json")
pass
self.send_process_state_db(self.group_names)
self.prev_current_time = int(time.time())
def get_system_mem_cpu_usage(self):
system_mem_cpu_usage_data = MemCpuUsageData(os.getpid())
return system_mem_cpu_usage_data.get_sys_mem_cpu_info()
def get_system_mem_cpu_usage(self):
system_mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
system_mem_cpu_usage = system_mem_cpu_usage_data.get_sys_mem_cpu_info()
self.last_cpu = system_mem_cpu_usage_data.last_cpu
self.last_time = system_mem_cpu_usage_data.last_time
return system_mem_cpu_usage
def event_tick_60(self):
self.tick_count += 1
for group in self.group_names:
key = next(key for key, pstat in self.process_state_db.items() if pstat.group == group)
# get disk usage info periodically
disk_usage_info = self.get_disk_usage()
# typical ntp sync time is about 5 min - first time,
# we scan only after 10 min
if self.tick_count >= 10:
self.check_ntp_status()
if self.update_process_core_file_list():
self.send_process_state_db(['default'])
process_mem_cpu_usage = self.get_group_processes_mem_cpu_usage(group)
# get system mem/cpu usage
system_mem_cpu_usage_data = MemCpuUsageData(os.getpid(), self.last_cpu, self.last_time)
system_mem_usage = system_mem_cpu_usage_data.get_sys_mem_info(self.uve_node_type)
system_cpu_usage = system_mem_cpu_usage_data.get_sys_cpu_info(self.uve_node_type)
# update last_cpu/time after all processing is complete
self.last_cpu = system_mem_cpu_usage_data.last_cpu
self.last_time = system_mem_cpu_usage_data.last_time
# send above encoded buffer
node_status = NodeStatus(name=self.process_state_db[key].name,
disk_usage_info=disk_usage_info,
system_mem_usage=system_mem_usage,
system_cpu_usage=system_cpu_usage,
process_mem_cpu_usage=process_mem_cpu_usage)
# encode other core file
if self.update_all_core_file():
node_status.all_core_file_list = self.all_core_file_list
installed_package_version = \
NodeMgrUtils.get_package_version(self.get_package_name())
if installed_package_version is None:
sys.stderr.write("Error getting %s package version\n"
% (self.get_package_name()))
installed_package_version = "package-version-unknown"
if (installed_package_version != self.installed_package_version):
node_status.installed_package_version = installed_package_version
node_status_uve = NodeStatusUVE(table=self.table,
data=node_status)
node_status_uve.send()
self.installed_package_version = installed_package_version
current_time = int(time.time())
if ((abs(current_time - self.prev_current_time)) > 300):
# update all process start_times with the updated time
# Compute the elapsed time and subtract them from
# current time to get updated values
sys.stderr.write(
"Time lapse detected " +
str(abs(current_time - self.prev_current_time)) + "\n")
for key in self.process_state_db:
pstat = self.process_state_db[key]
if pstat.start_time is not '':
pstat.start_time = str(
(int(current_time - (self.prev_current_time -
((int)(pstat.start_time)) / 1000000))) * 1000000)
if (pstat.process_state == 'PROCESS_STATE_STOPPED'):
if pstat.stop_time is not '':
pstat.stop_time = str(
int(current_time - (self.prev_current_time -
((int)(pstat.stop_time)) / 1000000)) *
1000000)
if (pstat.process_state == 'PROCESS_STATE_EXITED'):
if pstat.exit_time is not '':
pstat.exit_time = str(
int(current_time - (self.prev_current_time -
((int)(pstat.exit_time)) / 1000000)) *
1000000)
# update process state database
self.process_state_db[key] = pstat
try:
json_file = '/var/log/contrail/process_state' + \
self.node_type + ".json"
f = open(json_file, 'w')
f.write(
json.dumps(
self.process_state_db,
default=lambda obj: obj.__dict__))
except:
sys.stderr.write("Unable to write json")
pass
self.send_process_state_db(self.group_names)
self.prev_current_time = int(time.time())
def get_system_mem_cpu_usage(self):
system_mem_cpu_usage_data = MemCpuUsageData(os.getpid())
return system_mem_cpu_usage_data.get_sys_mem_cpu_info()
