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 login(self): """Logon to the server.""" ret = True if not self.args.snmp_force: # First of all, trying to connect to a Glances server self.set_mode('glances') client_version = None try: client_version = self.client.init() except socket.error as err: # Fallback to SNMP logger.error(_("Connection to Glances server failed")) self.set_mode('snmp') fallbackmsg = _("Trying fallback to SNMP...") print(fallbackmsg) except ProtocolError as err: # Others errors if str(err).find(" 401 ") > 0: logger.error( _("Connection to server failed (Bad password)")) else: logger.error( _("Connection to server failed ({0})").format(err)) sys.exit(2) if self.get_mode( ) == 'glances' and version[:3] == client_version[:3]: # Init stats self.stats = GlancesStatsClient() self.stats.set_plugins(json.loads(self.client.getAllPlugins())) else: logger.error("Client version: %s / Server version: %s" % (version, client_version)) else: self.set_mode('snmp') if self.get_mode() == 'snmp': logger.info(_("Trying to grab stats by SNMP...")) # Fallback to SNMP if needed from glances.core.glances_stats import GlancesStatsClientSNMP # Init stats self.stats = GlancesStatsClientSNMP(args=self.args) if not self.stats.check_snmp(): logger.error(_("Connection to SNMP server failed")) sys.exit(2) if ret: # Load limits from the configuration file # Each client can choose its owns limits self.stats.load_limits(self.config) # Init screen self.screen = GlancesCurses(args=self.args) # Return result return ret
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=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)
def login(self): """Logon to the server.""" ret = True if not self.args.snmp_force: # First of all, trying to connect to a Glances server self.set_mode('glances') client_version = None try: client_version = self.client.init() except socket.error as err: # Fallback to SNMP logger.error(_("Connection to Glances server failed")) self.set_mode('snmp') fallbackmsg = _("Trying fallback to SNMP...") print(fallbackmsg) except ProtocolError as err: # Others errors if str(err).find(" 401 ") > 0: logger.error(_("Connection to server failed (Bad password)")) else: logger.error(_("Connection to server failed ({0})").format(err)) sys.exit(2) if self.get_mode() == 'glances' and version[:3] == client_version[:3]: # Init stats self.stats = GlancesStatsClient() self.stats.set_plugins(json.loads(self.client.getAllPlugins())) else: logger.error("Client version: %s / Server version: %s" % (version, client_version)) else: self.set_mode('snmp') if self.get_mode() == 'snmp': logger.info(_("Trying to grab stats by SNMP...")) # Fallback to SNMP if needed from glances.core.glances_stats import GlancesStatsClientSNMP # Init stats self.stats = GlancesStatsClientSNMP(args=self.args) if not self.stats.check_snmp(): logger.error(_("Connection to SNMP server failed")) sys.exit(2) if ret: # Load limits from the configuration file # Each client can choose its owns limits self.stats.load_limits(self.config) # Init screen self.screen = GlancesCurses(args=self.args) # Return result return ret
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()
def login(self): """Logon to the server.""" ret = True # First of all, trying to connect to a Glances server try: client_version = self.client.init() self.set_mode('glances') except socket.error as err: # print(_("Error: Connection to {0} server failed").format(self.get_mode())) # Fallback to SNMP self.set_mode('snmp') except ProtocolError as err: # Others errors if str(err).find(" 401 ") > 0: print(_("Error: Connection to server failed: Bad password")) else: print(_("Error: Connection to server failed: {0}").format(err)) sys.exit(2) if self.get_mode() == 'glances' and version[:3] == client_version[:3]: # Init stats self.stats = GlancesStatsClient() self.stats.set_plugins(json.loads(self.client.getAllPlugins())) elif self.get_mode() == 'snmp': print (_("Info: Connection to Glances server failed. Trying fallback to SNMP...")) # Then fallback to SNMP if needed from glances.core.glances_stats import GlancesStatsClientSNMP # Init stats self.stats = GlancesStatsClientSNMP(args=self.args) if not self.stats.check_snmp(): print(_("Error: Connection to SNMP server failed")) sys.exit(2) else: ret = False if ret: # Load limits from the configuration file # Each client can choose its owns limits self.stats.load_limits(self.config) # Init screen self.screen = GlancesCurses(args=self.args) # Return result return ret
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): # 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 GlancesClient(object): """This class creates and manages the TCP client.""" def __init__(self, config=None, args=None): # Store the arg/config self.args = args self.config = config # Client mode: self.set_mode() # Build the URI if args.password != "": uri = 'http://{0}:{1}@{2}:{3}'.format(args.username, args.password, args.client, args.port) else: uri = 'http://{0}:{1}'.format(args.client, args.port) # Try to connect to the URI transport = GlancesClientTransport() # Configure the server timeout to 7 seconds transport.set_timeout(7) try: self.client = ServerProxy(uri, transport=transport) except Exception as e: logger.error(_("Couldn't create socket {0}: {1}").format(uri, e)) sys.exit(2) def set_mode(self, mode='glances'): """Set the client mode. - 'glances' = Glances server (default) - 'snmp' = SNMP (fallback) """ self.mode = mode return self.mode def get_mode(self): """Get the client mode. - 'glances' = Glances server (default) - 'snmp' = SNMP (fallback) """ return self.mode def login(self): """Logon to the server.""" ret = True if not self.args.snmp_force: # First of all, trying to connect to a Glances server self.set_mode('glances') client_version = None try: client_version = self.client.init() except socket.error as err: # Fallback to SNMP logger.error(_("Connection to Glances server failed")) self.set_mode('snmp') fallbackmsg = _("Trying fallback to SNMP...") print(fallbackmsg) except ProtocolError as err: # Others errors if str(err).find(" 401 ") > 0: logger.error( _("Connection to server failed (Bad password)")) else: logger.error( _("Connection to server failed ({0})").format(err)) sys.exit(2) if self.get_mode( ) == 'glances' and version[:3] == client_version[:3]: # Init stats self.stats = GlancesStatsClient() self.stats.set_plugins(json.loads(self.client.getAllPlugins())) else: logger.error("Client version: %s / Server version: %s" % (version, client_version)) else: self.set_mode('snmp') if self.get_mode() == 'snmp': logger.info(_("Trying to grab stats by SNMP...")) # Fallback to SNMP if needed from glances.core.glances_stats import GlancesStatsClientSNMP # Init stats self.stats = GlancesStatsClientSNMP(args=self.args) if not self.stats.check_snmp(): logger.error(_("Connection to SNMP server failed")) sys.exit(2) if ret: # Load limits from the configuration file # Each client can choose its owns limits self.stats.load_limits(self.config) # Init screen self.screen = GlancesCurses(args=self.args) # Return result return ret def update(self): """Update stats from Glances/SNMP server.""" if self.get_mode() == 'glances': return self.update_glances() elif self.get_mode() == 'snmp': return self.update_snmp() else: self.end() logger.critical( _("Unknown server mode: {0}").format(self.get_mode())) sys.exit(2) def update_glances(self): """Get stats from Glances server. Return the client/server connection status: - Connected: Connection OK - Disconnected: Connection NOK """ # Update the stats try: server_stats = json.loads(self.client.getAll()) server_stats['monitor'] = json.loads(self.client.getAllMonitored()) except socket.error: # Client cannot get server stats return "Disconnected" except Fault: # Client cannot get server stats (issue #375) return "Disconnected" else: # Put it in the internal dict self.stats.update(server_stats) return "Connected" def update_snmp(self): """Get stats from SNMP server. Return the client/server connection status: - SNMP: Connection with SNMP server OK - Disconnected: Connection NOK """ # Update the stats try: self.stats.update() except: # Client can not get SNMP server stats return "Disconnected" else: # Grab success return "SNMP" def serve_forever(self): """Main client loop.""" while True: # Update the stats cs_status = self.update() # Update the screen self.screen.update(self.stats, cs_status=cs_status) def end(self): """End of the client session.""" self.screen.end()
class GlancesClient(object): """This class creates and manages the TCP client.""" def __init__(self, config=None, args=None): # Store the arg/config self.args = args self.config = config # Client mode: self.set_mode() # Build the URI if args.password != "": uri = 'http://{0}:{1}@{2}:{3}'.format(args.username, args.password, args.client, args.port) else: uri = 'http://{0}:{1}'.format(args.client, args.port) # Try to connect to the URI try: self.client = ServerProxy(uri) except Exception as e: print(_("Error: Couldn't create socket {0}: {1}").format(uri, e)) sys.exit(2) def set_mode(self, mode='glances'): """Set the client mode. - 'glances' = Glances server (default) - 'snmp' = SNMP (fallback) """ self.mode = mode return self.mode def get_mode(self): """Get the client mode. - 'glances' = Glances server (default) - 'snmp' = SNMP (fallback) """ return self.mode def login(self): """Logon to the server.""" ret = True # First of all, trying to connect to a Glances server try: client_version = self.client.init() self.set_mode('glances') except socket.error as err: # print(_("Error: Connection to {0} server failed").format(self.get_mode())) # Fallback to SNMP self.set_mode('snmp') except ProtocolError as err: # Others errors if str(err).find(" 401 ") > 0: print(_("Error: Connection to server failed: Bad password")) else: print(_("Error: Connection to server failed: {0}").format(err)) sys.exit(2) if self.get_mode() == 'glances' and version[:3] == client_version[:3]: # Init stats self.stats = GlancesStatsClient() self.stats.set_plugins(json.loads(self.client.getAllPlugins())) elif self.get_mode() == 'snmp': print (_("Info: Connection to Glances server failed. Trying fallback to SNMP...")) # Then fallback to SNMP if needed from glances.core.glances_stats import GlancesStatsClientSNMP # Init stats self.stats = GlancesStatsClientSNMP(args=self.args) if not self.stats.check_snmp(): print(_("Error: Connection to SNMP server failed")) sys.exit(2) else: ret = False if ret: # Load limits from the configuration file # Each client can choose its owns limits self.stats.load_limits(self.config) # Init screen self.screen = GlancesCurses(args=self.args) # Return result return ret def update(self): """Update stats from Glances/SNMP server.""" if self.get_mode() == 'glances': return self.update_glances() elif self.get_mode() == 'snmp': return self.update_snmp() else: print(_("Error: Unknown server mode: {0}").format(self.get_mode())) sys.exit(2) def update_glances(self): """Get stats from Glances server. Return the client/server connection status: - Connected: Connection OK - Disconnected: Connection NOK """ # Update the stats try: server_stats = json.loads(self.client.getAll()) server_stats['monitor'] = json.loads(self.client.getAllMonitored()) except socket.error: # Client cannot get server stats return "Disconnected" except Fault: # Client cannot get server stats (issue #375) return "Disconnected" else: # Put it in the internal dict self.stats.update(server_stats) return "Connected" def update_snmp(self): """Get stats from SNMP server. Return the client/server connection status: - SNMP: Connection with SNMP server OK - Disconnected: Connection NOK """ # Update the stats try: self.stats.update() except: # Client can not get SNMP server stats return "Disconnected" else: # Grab success return "SNMP" def serve_forever(self): """Main client loop.""" while True: # Update the stats cs_status = self.update() # Update the screen self.screen.update(self.stats, cs_status=cs_status) # print self.stats # print self.stats.getAll() def end(self): """End of the client session.""" self.screen.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) # 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()