def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Default number of processes to displayed is set to 50
glances_processes.set_max_processes(50)
# If process extended stats is disabled by user
if not args.enable_process_extended:
logger.info(
"Extended stats for top process are disabled (default behavior)"
)
glances_processes.disable_extended()
else:
logger.debug("Extended stats for top process are enabled")
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
if args.process_tree:
# Enable process tree view
glances_processes.enable_tree()
# Initial system informations update
self.stats.update()
# Init screen
self.screen = GlancesCursesStandalone(args=args)
class GlancesWebServer(object):
"""This class creates and manages the Glances Web server session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config)
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
# Initial system informations update
self.stats.update()
# Init the Bottle Web server
self.web = GlancesBottle(args=args)
def serve_forever(self):
"""Main loop for the Web server."""
self.web.start(self.stats)
def end(self):
"""End of the Web server."""
self.web.end()
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Default number of processes to displayed is set to 20
glances_processes.set_max_processes(20)
# If process extended stats is disabled by user
if args.disable_process_extended:
logger.info(_("Extended stats for top process is disabled"))
glances_processes.disable_extended()
else:
logger.debug(
_("Extended stats for top process is enabled (default behavor)"
))
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
class GlancesWebServer(object):
"""This class creates and manages the Glances Web server session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config)
if not is_windows and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
# Initial system informations update
self.stats.update()
# Init the Bottle Web server
self.web = GlancesBottle(args=args)
def serve_forever(self):
"""Main loop for the Web server."""
self.web.start(self.stats)
def end(self):
"""End of the Web server."""
self.web.end()
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Default number of processes to displayed is set to 20
glances_processes.set_max_processes(20)
# If process extended stats is disabled by user
if args.disable_process_extended:
logger.info(_("Extended stats for top process is disabled"))
glances_processes.disable_extended()
else:
logger.debug(
_("Extended stats for top process is enabled (default behavor)"
))
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
def serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
# Update the screen
self.screen.update(self.stats)
# Update the CSV output
if self.csv_tag:
self.csvoutput.update(self.stats)
def end(self):
"""End of the CLI."""
self.screen.end()
# Close the CSV file
if self.csv_tag:
self.csvoutput.exit()
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Default number of processes to displayed is set to 50
glances_processes.set_max_processes(50)
# If process extended stats is disabled by user
if args.disable_process_extended:
logger.info(_("Extended stats for top process is disabled"))
glances_processes.disable_extended()
else:
logger.debug(_("Extended stats for top process is enabled (default behavor)"))
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
def serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
# Update the screen
self.screen.update(self.stats)
# Update the CSV output
if self.csv_tag:
self.csvoutput.update(self.stats)
def end(self):
"""End of the CLI."""
self.screen.end()
# Close the CSV file
if self.csv_tag:
self.csvoutput.exit()
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config)
# Initial system informations update
self.stats.update()
# Init the Bottle Web server
self.web = GlancesBottle(args=args)
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config)
if not is_windows and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
# Initial system informations update
self.stats.update()
# Init the Bottle Web server
self.web = GlancesBottle(args=args)
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Default number of processes to displayed is set to 50
glances_processes.set_max_processes(50)
# If process extended stats is disabled by user
if not args.enable_process_extended:
logger.info("Extended stats for top process are disabled (default behavior)")
glances_processes.disable_extended()
else:
logger.debug("Extended stats for top process are enabled")
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
if args.process_tree:
# Enable process tree view
glances_processes.enable_tree()
# Initial system informations update
self.stats.update()
# Init screen
self.screen = GlancesCursesStandalone(args=args)
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Default number of processes to displayed is set to 50
glances_processes.set_max_processes(50)
# If process extended stats is disabled by user
if args.disable_process_extended:
logger.info(_("Extended stats for top process is disabled"))
glances_processes.disable_extended()
else:
logger.debug(_("Extended stats for top process is enabled (default behavor)"))
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# If configured, set the maximum processes number to display
try:
max_processes = int(
self.stats.get_plugin('processlist').get_conf_value(
'max_processes'))
logger.debug(
_("Limit maximum displayed processes to %s") % max_processes)
except:
max_processes = None
logger.warning(
_("Maximum displayed processes is not configured (high CPU consumption)"
))
glances_processes.set_max_processes(max_processes)
# If process extended stats is disabled by user
if args.disable_process_extended:
logger.info(_("Extended stats for top process is disabled"))
glances_processes.disable_extended()
else:
logger.debug(
_("Extended stats for top process is enabled (default behavor)"
))
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Default number of processes to displayed is set to 50
glances_processes.set_max_processes(50)
# If process extended stats is disabled by user
if not args.enable_process_extended:
logger.info("Extended stats for top process are disabled (default behavior)")
glances_processes.disable_extended()
else:
logger.debug("Extended stats for top process are enabled")
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
if args.process_tree:
# Enable process tree view
glances_processes.enable_tree()
# Initial system informations update
self.stats.update()
# Init screen
self.screen = GlancesCursesStandalone(args=args)
def serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
# Update the screen
self.screen.update(self.stats)
# Export stats using export modules
self.stats.export(self.stats)
def end(self):
"""End of the standalone CLI."""
self.screen.end()
# Exit from export modules
self.stats.end()
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Default number of processes to displayed is set to 50
glances_processes.set_max_processes(50)
# If process extended stats is disabled by user
if not args.enable_process_extended:
logger.info(
"Extended stats for top process are disabled (default behavior)"
)
glances_processes.disable_extended()
else:
logger.debug("Extended stats for top process are enabled")
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
if args.process_tree:
# Enable process tree view
glances_processes.enable_tree()
# Initial system informations update
self.stats.update()
# Init screen
self.screen = GlancesCursesStandalone(args=args)
def serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
# Update the screen
self.screen.update(self.stats)
# Export stats using export modules
self.stats.export(self.stats)
def end(self):
"""End of the standalone CLI."""
self.screen.end()
# Exit from export modules
self.stats.end()
def __init__(self, config=None, args=None):
# Quiet mode
self._quiet = args.quiet
self.refresh_time = args.time
# Init stats
self.stats = GlancesStats(config=config, args=args)
# If process extended stats is disabled by user
if not args.enable_process_extended:
logger.debug("Extended stats for top process are disabled")
glances_processes.disable_extended()
else:
logger.debug("Extended stats for top process are enabled")
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.process_filter = args.process_filter
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
try:
if args.process_tree:
# Enable process tree view
glances_processes.enable_tree()
except AttributeError:
pass
# Initial system informations update
self.stats.update()
if self.quiet:
logger.info("Quiet mode is ON: Nothing will be displayed")
# In quiet mode, nothing is displayed
glances_processes.max_processes = 0
else:
# Default number of processes to displayed is set to 50
glances_processes.max_processes = 50
# Init screen
self.screen = GlancesCursesStandalone(args=args)
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
def serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
# Update the screen
self.screen.update(self.stats)
# Update the CSV output
if self.csv_tag:
self.csvoutput.update(self.stats)
def end(self):
"""End of the CLI."""
self.screen.end()
# Close the CSV file
if self.csv_tag:
self.csvoutput.exit()
class GlancesWebServer(object):
"""This class creates and manages the Glances Web server session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config)
# Initial system informations update
self.stats.update()
# Init the Bottle Web server
self.web = GlancesBottle(args=args)
def serve_forever(self):
"""Main loop for the Web server."""
self.web.start(self.stats)
def end(self):
"""End of the Web server."""
self.web.end()
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config)
if not is_windows and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
# Initial system informations update
self.stats.update()
# Init the Bottle Web server
self.web = GlancesBottle(args=args)
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
def __init__(self, config=None, args=None):
# Quiet mode
self._quiet = args.quiet
self.refresh_time = args.time
# Init stats
self.stats = GlancesStats(config=config, args=args)
# If process extended stats is disabled by user
if not args.enable_process_extended:
logger.debug("Extended stats for top process are disabled")
glances_processes.disable_extended()
else:
logger.debug("Extended stats for top process are enabled")
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.process_filter = args.process_filter
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
try:
if args.process_tree:
# Enable process tree view
glances_processes.enable_tree()
except AttributeError:
pass
# Initial system informations update
self.stats.update()
if self.quiet:
logger.info("Quiet mode is ON: Nothing will be displayed")
# In quiet mode, nothing is displayed
glances_processes.max_processes = 0
else:
# Default number of processes to displayed is set to 50
glances_processes.max_processes = 50
# Init screen
self.screen = GlancesCursesStandalone(args=args)
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# If configured, set the maximum processes number to display
try:
max_processes = int(self.stats.get_plugin('processlist').get_conf_value('max_processes'))
logger.debug(_("Limit maximum displayed processes to %s") % max_processes)
except:
max_processes = None
logger.warning(_("Maximum displayed processes is not configured (high CPU consumption)"))
glances_processes.set_max_processes(max_processes)
# If process extended stats is disabled by user
if args.disable_process_extended:
logger.info(_("Extended stats for top process is disabled"))
glances_processes.disable_extended()
else:
logger.debug(_("Extended stats for top process is enabled (default behavor)"))
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# If configured, set the maximum processes number to display
try:
max_processes = int(
self.stats.get_plugin('processlist').get_conf_value(
'max_processes'))
logger.debug(
_("Limit maximum displayed processes to %s") % max_processes)
except:
max_processes = None
logger.warning(
_("Maximum displayed processes is not configured (high CPU consumption)"
))
glances_processes.set_max_processes(max_processes)
# If process extended stats is disabled by user
if args.disable_process_extended:
logger.info(_("Extended stats for top process is disabled"))
glances_processes.disable_extended()
else:
logger.debug(
_("Extended stats for top process is enabled (default behavor)"
))
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
def serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
# Update the screen
self.screen.update(self.stats)
# Update the CSV output
if self.csv_tag:
self.csvoutput.update(self.stats)
def end(self):
"""End of the CLI."""
self.screen.end()
# Close the CSV file
if self.csv_tag:
self.csvoutput.exit()
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config=config, args=args)
# If configured, set the maximum processes number to display
try:
max_processes = int(self.stats.get_plugin('processlist').get_conf_value('max_processes'))
logger.debug(_("Limit maximum displayed processes to %s") % max_processes)
except:
max_processes = None
logger.warning(_("Maximum displayed processes is not configured (high CPU consumption)"))
glances_processes.set_max_processes(max_processes)
# If process extended stats is disabled by user
if args.disable_process_extended:
logger.info(_("Extended stats for top process is disabled"))
glances_processes.disable_extended()
else:
logger.debug(_("Extended stats for top process is enabled (default behavor)"))
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.set_process_filter(args.process_filter)
# Initial system informations update
self.stats.update()
# Init CSV output
if args.output_csv is not None:
from glances.outputs.glances_csv import GlancesCSV
self.csvoutput = GlancesCSV(args=args)
self.csv_tag = True
else:
self.csv_tag = False
# Init screen
self.screen = GlancesCurses(args=args)
def serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
# Update the screen
self.screen.update(self.stats)
# Update the CSV output
if self.csv_tag:
self.csvoutput.update(self.stats)
def end(self):
"""End of the CLI."""
self.screen.end()
# Close the CSV file
if self.csv_tag:
self.csvoutput.exit()
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Quiet mode
self._quiet = args.quiet
self.refresh_time = args.time
# Init stats
self.stats = GlancesStats(config=config, args=args)
# If process extended stats is disabled by user
if not args.enable_process_extended:
logger.debug("Extended stats for top process are disabled")
glances_processes.disable_extended()
else:
logger.debug("Extended stats for top process are enabled")
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.process_filter = args.process_filter
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
try:
if args.process_tree:
# Enable process tree view
glances_processes.enable_tree()
except AttributeError:
pass
# Initial system informations update
self.stats.update()
if self.quiet:
logger.info("Quiet mode is ON: Nothing will be displayed")
# In quiet mode, nothing is displayed
glances_processes.max_processes = 0
else:
# Default number of processes to displayed is set to 50
glances_processes.max_processes = 50
# Init screen
self.screen = GlancesCursesStandalone(args=args)
@property
def quiet(self):
return self._quiet
def __serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
if not self.quiet:
# Update the screen
self.screen.update(self.stats)
else:
# Wait...
sleep(self.refresh_time)
# Export stats using export modules
self.stats.export(self.stats)
def serve_forever(self):
"""Wrapper to the serve_forever function.
This function will restore the terminal to a sane state
before re-raising the exception and generating a traceback.
"""
try:
return self.__serve_forever()
finally:
self.end()
def end(self):
"""End of the standalone CLI."""
if not self.quiet:
self.screen.end()
# Exit from export modules
self.stats.end()
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
# Quiet mode
self._quiet = args.quiet
self.refresh_time = args.time
# Init stats
self.stats = GlancesStats(config=config, args=args)
# If process extended stats is disabled by user
if not args.enable_process_extended:
logger.debug("Extended stats for top process are disabled")
glances_processes.disable_extended()
else:
logger.debug("Extended stats for top process are enabled")
glances_processes.enable_extended()
# Manage optionnal process filter
if args.process_filter is not None:
glances_processes.process_filter = args.process_filter
if (not is_windows) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
try:
if args.process_tree:
# Enable process tree view
glances_processes.enable_tree()
except AttributeError:
pass
# Initial system informations update
self.stats.update()
if self.quiet:
logger.info("Quiet mode is ON: Nothing will be displayed")
# In quiet mode, nothing is displayed
glances_processes.max_processes = 0
else:
# Default number of processes to displayed is set to 50
glances_processes.max_processes = 50
# Init screen
self.screen = GlancesCursesStandalone(args=args)
@property
def quiet(self):
return self._quiet
def __serve_forever(self):
"""Main loop for the CLI."""
while True:
# Update system informations
self.stats.update()
if not self.quiet:
# Update the screen
self.screen.update(self.stats)
else:
# Wait...
sleep(self.refresh_time)
# Export stats using export modules
self.stats.export(self.stats)
def serve_forever(self):
"""Wrapper to the serve_forever function.
This function will restore the terminal to a sane state
before re-raising the exception and generating a traceback.
"""
try:
return self.__serve_forever()
finally:
self.end()
def end(self):
"""End of the standalone CLI."""
if not self.quiet:
self.screen.end()
# Exit from export modules
self.stats.end()
# Import local settings
from glances.core.glances_globals import gettext_domain, locale_dir
locale.setlocale(locale.LC_ALL, '')
gettext.install(gettext_domain, locale_dir)
# Init Glances core
from glances.core.glances_main import GlancesMain
core = GlancesMain()
if not core.is_standalone():
print('ERROR: Glances core should be ran in standalone mode')
sys.exit(1)
# Init Glances stats
from glances.core.glances_stats import GlancesStats
stats = GlancesStats()
# Unitest class
# ==============
class TestGlances(unittest.TestCase):
"""Test Glances class."""
def setUp(self):
"""The function is called *every time* before test_*."""
print('\n' + '=' * 78)
def test_000_start_server(self):
"""Start the Glances Web Server"""
print('INFO: [TEST_000] Start the Glances Web Server')
