path: root/src/glances.py

#!/usr/bin/python
#
# Glances is a simple CLI monitoring tool based on libstatgrab
#
# Pre-requisites: python-statgrab 0.5 or >
#
# Copyright (C) Nicolargo 2011 <nicolas@nicolargo.com>
# 
# under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# glances is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU Lesser General Public License for more details.
# 
# You should have received a copy of the GNU Lesser General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.";
#

import os
import getopt
import sys
import signal
import time
import datetime
import curses
import statgrab


# Globals variables
#==================

# The glances version id
__version__ = "1.1.3"		

# Class
#======

class glancesStats():
	"""
	This class store, update and give the libstatgrab stats
	"""

	def __init__(self):
		"""
		Init the libstatgrab and process to the first update
		"""
		
		# Init libstatgrab
		if not statgrab.sg_init():
			print "Error: Can not init the libstatgrab library.\n"
		# Do the first update
		self.__update__()

	def __update__(self):
		"""
		Update the stats
		"""

		# Get informations from libstatgrab and others...
		self.host = statgrab.sg_get_host_info()
		self.system = statgrab.sg_get_host_info()
		self.cpu = statgrab.sg_get_cpu_percents()
		self.load = statgrab.sg_get_load_stats()
		self.mem = statgrab.sg_get_mem_stats()
		self.memswap = statgrab.sg_get_swap_stats()
		self.network = statgrab.sg_get_network_io_stats_diff()
		self.diskio = statgrab.sg_get_disk_io_stats_diff()
		# BUG: https://bugs.launchpad.net/ubuntu/+source/libstatgrab/+bug/886783
		# TODO: self.fs = statgrab.sg_get_fs_stats()
		self.processcount = statgrab.sg_get_process_count()
		self.process = statgrab.sg_get_process_stats()
		self.now = datetime.datetime.now()		

		
	def end(self):
		# Shutdown the libstatgrab
		statgrab.sg_shutdown()

		
	def update(self):
		# Update the stats
		self.__update__()

		
	def getHost(self):
		return self.host

		
	def getSystem(self):
		return self.system

		
	def getCpu(self):
		return self.cpu

		
	def getLoad(self):
		return self.load

		
	def getMem(self):
		return self.mem

		
	def getMemSwap(self):
		return self.memswap

		
	def getNetwork(self):
		return self.network

		
	def getDiskIO(self):
		return self.diskio

		
	def getProcessCount(self):
		return self.processcount

		
	def getProcessList(self, sortedby = 'auto'):
		"""
		Return the sorted process list		
		"""
		
		if sortedby == 'auto':
			# If global Mem > 70% sort by process size
			# Else sort by cpu comsoption
			sortedby = 'cpu_percent'
			if ( self.mem['total'] != 0):
				if ( ( (self.mem['used'] - self.mem['cache']) * 100 / self.mem['total']) > 70):
					sortedby = 'proc_size'
		return sorted(self.process, key=lambda process: process[sortedby], reverse=True)

		
	def getNow(self):
		return self.now	

		
class glancesScreen():
	"""
	This class manage the screen (display and key pressed)
	"""

	# By default the process list is automaticaly sorted
	# If global CPU > 75% 		=> Sorted by process Cpu consomption
	# If global used MEM > 75% 	=> Sorted by process size 
	__process_sortedby = 'auto'
	
	def __init__(self, refresh_time = 1):
		# Global information to display
		self.__version = __version__

		# Init windows positions
		self.term_h = 		24 ; 		self.term_w = 		80
		self.host_x = 		0 ; 		self.host_y = 		0
		self.system_x = 	0 ; 		self.system_y = 	1
		self.cpu_x = 		0 ; 		self.cpu_y = 		3
		self.load_x = 		20; 		self.load_y = 		3
		self.mem_x = 		41; 		self.mem_y = 		3
		self.network_x = 	0 ; 		self.network_y = 	9
		self.diskio_x = 	0 ; 		self.diskio_y = 	16
		self.process_x = 	30;			self.process_y = 	9
		self.now_x = 		79;			self.now_y = 		23	 # Align right
		self.caption_x = 	0 ;			self.caption_y = 	23

		# Init the curses screen
		self.screen = curses.initscr() 
		if not self.screen:
			print "Error: Can not init the curses library.\n"
		curses.resizeterm( self.term_h, self.term_w )
		curses.start_color()
		curses.use_default_colors()
		curses.noecho() ; curses.cbreak() ; curses.curs_set(0)
		
		# Init colors
		self.hascolors = False
		if curses.has_colors():
			self.hascolors = True
			#Init				FG color				BG color
			curses.init_pair(1, curses.COLOR_WHITE, 	curses.COLOR_BLACK)
			curses.init_pair(2, curses.COLOR_WHITE, 	curses.COLOR_RED)
			curses.init_pair(3, curses.COLOR_WHITE, 	curses.COLOR_GREEN)
			curses.init_pair(4, curses.COLOR_WHITE, 	curses.COLOR_BLUE)
			curses.init_pair(5, curses.COLOR_WHITE, 	curses.COLOR_MAGENTA)
			curses.init_pair(6, curses.COLOR_WHITE, 	curses.COLOR_CYAN)
			curses.init_pair(7, curses.COLOR_BLACK, 	curses.COLOR_YELLOW)

			# Text colors/styles
			self.title_color = curses.A_BOLD|curses.A_UNDERLINE
			self.no_color = curses.color_pair(1)
			self.default_color = curses.color_pair(3)|curses.A_BOLD
			self.if50pc_color = curses.color_pair(4)|curses.A_BOLD
			self.if70pc_color = curses.color_pair(5)|curses.A_BOLD
			self.if90pc_color = curses.color_pair(2)|curses.A_BOLD

		# Init window		
		self.term_window = curses.newwin(self.term_h, self.term_w, 0, 0)

		# Init refresh time
		self.__refresh_time = refresh_time

		# Catch key pressed with non blocking mode
		self.term_window.keypad(1) ; self.term_window.nodelay(1) ; self.pressedkey = -1

		
	def setProcessSortedBy(self, sorted):
		self.__process_sortedautoflag = False
		self.__process_sortedby = sorted

		
	def getProcessSortedBy(self):
		return self.__process_sortedby

		
	def __getColor(self, current = 0, max = 100):
		# If current > 50% of max then color = self.if50pc_color / A_DIM
		# If current > 70% of max then color = self.if70pc_color / A_BOLD
		# If current > 90% of max then color = self.if90pc_color / A_REVERSE
		# By default: color = self.default_color / 0
		try:
			(current * 100) / max
		except ZeroDivisionError:
			return self.no_color

		variable = (current * 100) / max

		if variable > 90:
			if self.hascolors:
				return self.if90pc_color
			else:
				return curses.A_REVERSE
		elif variable > 70:
			if self.hascolors:
				return self.if70pc_color
			else:
				return curses.A_BOLD
		elif variable > 50:
			if self.hascolors:
				return self.if50pc_color
			else:
				return curses.A_DIM
		else:
			if self.hascolors:
				return self.default_color
			else:
				return 0

				
	def __catchKey(self):
		# Get key
		self.pressedkey = self.term_window.getch();

		# Actions...
		if (self.pressedkey == 27) or (self.pressedkey == 113):
			# 'ESC'|'q' > Exit
			end()
		elif (self.pressedkey == 97):
			# 'a' > Sort process list automaticaly
			self.setProcessSortedBy('auto')
		elif (self.pressedkey == 99):
			# 'c' > Sort process list by Cpu usage
			self.setProcessSortedBy('cpu_percent')
		elif (self.pressedkey == 109):
			# 'm' > Sort process list by Mem usage
			self.setProcessSortedBy('proc_size')

			
	def end(self):
		# Shutdown the curses window
		curses.echo() ; curses.nocbreak() ; curses.curs_set(1)
		curses.endwin()

		
	def update(self):
		# Refresh the screen
		self.term_window.refresh()

		# Sleep
		#curses.napms(self.__refresh_time*1000)
		time.sleep(self.__refresh_time)

		# Getkey
		self.__catchKey()

		
	def erase(self):
		# Erase the content of the screen
		self.term_window.erase()

		
	def displayHost(self, host):
		# Host information
		host_msg = "Glances v"+self.__version+" running on "+host['hostname'] #+" "+str(pressed_key)
		self.term_window.addnstr(self.host_y, self.host_x+40-len(host_msg)/2, host_msg, 80, self.title_color if self.hascolors else 0)

		
	def displaySystem(self, system):
		# System information
		system_msg = system['os_name']+" "+syst