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, args)
if not 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(config=config, 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()
self.stats.end()
def __init__(self, config=None, args=None):
self.config = config
self.args = args
# Quiet mode
self._quiet = args.quiet
self.refresh_time = args.time
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Modules (plugins and exporters) are loaded at this point
# Glances can display the list if asked...
if args.modules_list:
self.display_modules_list()
sys.exit(0)
# 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 WINDOWS) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
# 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
elif args.stdout:
logger.info("Stdout mode is ON, following stats will be displayed: {}".format(args.stdout))
# Init screen
self.screen = GlancesStdout(config=config, args=args)
elif args.stdout_csv:
logger.info("Stdout CSV mode is ON, following stats will be displayed: {}".format(args.stdout))
# Init screen
self.screen = GlancesStdoutCsv(config=config, args=args)
else:
# Default number of processes to displayed is set to 50
glances_processes.max_processes = 50
# Init screen
self.screen = GlancesCursesStandalone(config=config, args=args)
# Check the latest Glances version
self.outdated = Outdated(config=config, args=args)
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config, args)
if not 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(config=config, 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 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(config=config, args=args)
# Check the latest Glances version
self.outdated = Outdated(config=config, args=args)
# Create the schedule instance
self.schedule = sched.scheduler(timefunc=time.time,
delayfunc=time.sleep)
def __init__(self, config=None, args=None):
# Init stats
self.stats = GlancesStats(config, args)
if not 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(config=config, 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 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(config=config, args=args)
# Check the latest Glances version
self.outdated = Outdated(config=config, args=args)
# Create the schedule instance
self.schedule = sched.scheduler(
timefunc=time.time, delayfunc=time.sleep)
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, args)
if not 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(config=config, 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()
self.stats.end()
import time
import unittest
# Global variables
# =================
# Init Glances core
from 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.stats import GlancesStats
stats = GlancesStats()
from glances import __version__
from glances.globals import WINDOWS, LINUX
from glances.outputs.glances_bars import Bar
# Unitest class
# ==============
print('Unitary tests for Glances %s' % __version__)
class TestGlances(unittest.TestCase):
"""Test Glances class."""
def setUp(self):
"""The function is called *every time* before test_*."""
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 optional process filter
if args.process_filter is not None:
glances_processes.process_filter = args.process_filter
if (not 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 information 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 information
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 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(config=config, args=args)
# Check the latest Glances version
self.outdated = Outdated(config=config, args=args)
# Create the schedule instance
self.schedule = sched.scheduler(timefunc=time.time,
delayfunc=time.sleep)
@property
def quiet(self):
return self._quiet
def __serve_forever(self):
"""Main loop for the CLI."""
# Reschedule the function inside itself
self.schedule.enter(self.refresh_time,
priority=0,
action=self.__serve_forever,
argument=())
# Update system informations
self.stats.update()
# Update the screen
if not self.quiet:
self.screen.update(self.stats)
# 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.
"""
self.__serve_forever()
try:
self.schedule.run()
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()
# Check Glances version versus Pypi one
if self.outdated.is_outdated():
print(
"You are using Glances version {}, however version {} is available."
.format(self.outdated.installed_version(),
self.outdated.latest_version()))
print(
"You should consider upgrading using: pip install --upgrade glances"
)
from glances.thresholds import GlancesThresholdOk
from glances.thresholds import GlancesThresholdCareful
from glances.thresholds import GlancesThresholdWarning
from glances.thresholds import GlancesThresholdCritical
from glances.thresholds import GlancesThresholds
from glances.plugins.glances_plugin import GlancesPlugin
from glances.compat import subsample, range
# Global variables
# =================
# Init Glances core
core = GlancesMain()
# Init Glances stats
stats = GlancesStats(config=core.get_config(), args=core.get_args())
# Unitest class
# ==============
print('Unitary tests for Glances %s' % __version__)
class TestGlances(unittest.TestCase):
"""Test Glances class."""
def setUp(self):
"""The function is called *every time* before test_*."""
print('\n' + '=' * 78)
def test_000_update(self):
"""Update stats (mandatory step for all the stats).
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
self.config = config
self.args = args
# Quiet mode
self._quiet = args.quiet
self.refresh_time = args.time
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Modules (plugins and exporters) are loaded at this point
# Glances can display the list if asked...
if args.modules_list:
self.display_modules_list()
sys.exit(0)
# 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 WINDOWS) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
# 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
elif args.stdout:
logger.info("Stdout mode is ON, following stats will be displayed: {}".format(args.stdout))
# Init screen
self.screen = GlancesStdout(config=config, args=args)
else:
# Default number of processes to displayed is set to 50
glances_processes.max_processes = 50
# Init screen
self.screen = GlancesCursesStandalone(config=config, args=args)
# Check the latest Glances version
self.outdated = Outdated(config=config, args=args)
@property
def quiet(self):
return self._quiet
def display_modules_list(self):
"""Display modules list"""
print("Plugins list: {}".format(
', '.join(sorted(self.stats.getPluginsList(enable=False)))))
print("Exporters list: {}".format(
', '.join(sorted(self.stats.getExportsList(enable=False)))))
def __serve_forever(self):
"""Main loop for the CLI.
return True if we should continue (no exit key has been pressed)
"""
# Start a counter used to compute the time needed for
# update and export the stats
counter = Counter()
# Update stats
self.stats.update()
logger.debug('Stats updated in {} seconds'.format(counter.get()))
# Export stats
counter_export = Counter()
self.stats.export(self.stats)
logger.debug('Stats exported in {} seconds'.format(counter_export.get()))
# Display stats
# and wait refresh_time - counter
if not self.quiet:
# The update function return True if an exit key 'q' or 'ESC'
# has been pressed.
ret = not self.screen.update(self.stats,
duration=self.refresh_time - counter.get())
else:
# Nothing is displayed
# Break should be done via a signal (CTRL-C)
time.sleep(self.refresh_time - counter.get())
ret = True
return ret
def serve_forever(self):
"""Wrapper to the serve_forever function."""
loop = True
while loop:
loop = self.__serve_forever()
self.end()
def end(self):
"""End of the standalone CLI."""
if not self.quiet:
self.screen.end()
# Exit from export modules
self.stats.end()
# Check Glances version versus PyPI one
if self.outdated.is_outdated():
print("You are using Glances version {}, however version {} is available.".format(
self.outdated.installed_version(), self.outdated.latest_version()))
print("You should consider upgrading using: pip install --upgrade glances")
class GlancesStandalone(object):
"""This class creates and manages the Glances standalone session."""
def __init__(self, config=None, args=None):
self.config = config
self.args = args
# Quiet mode
self._quiet = args.quiet
self.refresh_time = args.time
# Init stats
self.stats = GlancesStats(config=config, args=args)
# Modules (plugins and exporters) are loaded at this point
# Glances can display the list if asked...
if args.modules_list:
self.display_modules_list()
sys.exit(0)
# 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 WINDOWS) and args.no_kernel_threads:
# Ignore kernel threads in process list
glances_processes.disable_kernel_threads()
# 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
elif args.stdout:
logger.info("Stdout mode is ON, following stats will be displayed: {}".format(args.stdout))
# Init screen
self.screen = GlancesStdout(config=config, args=args)
elif args.stdout_csv:
logger.info("Stdout CSV mode is ON, following stats will be displayed: {}".format(args.stdout))
# Init screen
self.screen = GlancesStdoutCsv(config=config, args=args)
else:
# Default number of processes to displayed is set to 50
glances_processes.max_processes = 50
# Init screen
self.screen = GlancesCursesStandalone(config=config, args=args)
# Check the latest Glances version
self.outdated = Outdated(config=config, args=args)
@property
def quiet(self):
return self._quiet
def display_modules_list(self):
"""Display modules list"""
print("Plugins list: {}".format(
', '.join(sorted(self.stats.getPluginsList(enable=False)))))
print("Exporters list: {}".format(
', '.join(sorted(self.stats.getExportsList(enable=False)))))
def __serve_forever(self):
"""Main loop for the CLI.
return True if we should continue (no exit key has been pressed)
"""
# Start a counter used to compute the time needed for
# update and export the stats
counter = Counter()
# Update stats
self.stats.update()
logger.debug('Stats updated in {} seconds'.format(counter.get()))
# Export stats
counter_export = Counter()
self.stats.export(self.stats)
logger.debug('Stats exported in {} seconds'.format(counter_export.get()))
# Patch for issue1326 to avoid < 0 refresh
adapted_refresh = self.refresh_time - counter.get()
adapted_refresh = adapted_refresh if adapted_refresh > 0 else 0
# Display stats
# and wait refresh_time - counter
if not self.quiet:
# The update function return True if an exit key 'q' or 'ESC'
# has been pressed.
ret = not self.screen.update(self.stats, duration=adapted_refresh)
else:
# Nothing is displayed
# Break should be done via a signal (CTRL-C)
time.sleep(adapted_refresh)
ret = True
return ret
def serve_forever(self):
"""Wrapper to the serve_forever function."""
loop = True
while loop:
loop = self.__serve_forever()
self.end()
def end(self):
"""End of the standalone CLI."""
if not self.quiet:
self.screen.end()
# Exit from export modules
self.stats.end()
# Check Glances version versus PyPI one
if self.outdated.is_outdated():
print("You are using Glances version {}, however version {} is available.".format(
self.outdated.installed_version(), self.outdated.latest_version()))
print("You should consider upgrading using: pip install --upgrade glances")
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 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(config=config, args=args)
# Check the latest Glances version
self.outdated = Outdated(config=config, args=args)
# Create the schedule instance
self.schedule = sched.scheduler(
timefunc=time.time, delayfunc=time.sleep)
@property
def quiet(self):
return self._quiet
def __serve_forever(self):
"""Main loop for the CLI."""
# Reschedule the function inside itself
self.schedule.enter(self.refresh_time, priority=0,
action=self.__serve_forever, argument=())
# Update system informations
self.stats.update()
# Update the screen
if not self.quiet:
self.screen.update(self.stats)
# 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.
"""
self.__serve_forever()
try:
self.schedule.run()
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()
# Check Glances version versus Pypi one
if self.outdated.is_outdated():
print("You are using Glances version {}, however version {} is available.".format(
self.outdated.installed_version(), self.outdated.latest_version()))
print("You should consider upgrading using: pip install --upgrade glances")