nicolargo / glances

glances/client_browser.py

# -*- coding: utf-8 -*-
#
# This file is part of Glances.
#
# Copyright (C) 2019 Nicolargo <nicolas@nicolargo.com>
#
# Glances is free software; you can redistribute it and/or modify
# it 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/>.

"""Manage the Glances client browser (list of Glances server)."""

import json

import missing from __future__ import absolute_import

import socket

import missing from __future__ import absolute_import

import threading

import missing from __future__ import absolute_import

from glances.compat import Fault, ProtocolError, ServerProxy

import missing from __future__ import absolute_import

from glances.client import GlancesClient, GlancesClientTransport

import missing from __future__ import absolute_import

from glances.logger import logger, LOG_FILENAME

import missing from __future__ import absolute_import

from glances.password_list import GlancesPasswordList as GlancesPassword

import missing from __future__ import absolute_import

from glances.static_list import GlancesStaticServer

import missing from __future__ import absolute_import

from glances.autodiscover import GlancesAutoDiscoverServer

import missing from __future__ import absolute_import

from glances.outputs.glances_curses_browser import GlancesCursesBrowser

import missing from __future__ import absolute_import

class GlancesClientBrowser(object):

    """This class creates and manages the TCP client browser (servers list)."""

    def __init__(self, config=None, args=None):
        # Store the arg/config
        self.args = args
        self.config = config
        self.static_server = None
        self.password = None

        # Load the configuration file
        self.load()

        # Start the autodiscover mode (Zeroconf listener)
        if not self.args.disable_autodiscover:
            self.autodiscover_server = GlancesAutoDiscoverServer()
        else:
            self.autodiscover_server = None

        # Init screen
        self.screen = GlancesCursesBrowser(args=self.args)

    def load(self):
        """Load server and password list from the confiuration file."""
        # Init the static server list (if defined)
        self.static_server = GlancesStaticServer(config=self.config)

        # Init the password list (if defined)
        self.password = GlancesPassword(config=self.config)

    def get_servers_list(self):
        """Return the current server list (list of dict).

        Merge of static + autodiscover servers list.
        """
        ret = []

        if self.args.browser:
            ret = self.static_server.get_servers_list()
            if self.autodiscover_server is not None:
                ret = self.static_server.get_servers_list() + self.autodiscover_server.get_servers_list()

This line is too long as per the coding-style (105/80).

        return ret

    def __get_uri(self, server):
        """Return the URI for the given server dict."""
        # Select the connection mode (with or without password)
        if server['password'] != "":
            if server['status'] == 'PROTECTED':
                # Try with the preconfigure password (only if status is PROTECTED)

This line is too long as per the coding-style (82/80).

                clear_password = self.password.get_password(server['name'])
                if clear_password is not None:
                    server['password'] = self.password.sha256_hash(clear_password)

This line is too long as per the coding-style (82/80).

            return 'http://{}:{}@{}:{}'.format(server['username'], server['password'],

This line is too long as per the coding-style (86/80).

                                               server['ip'], server['port'])
        else:
            return 'http://{}:{}'.format(server['ip'], server['port'])

    def __update_stats(self, server):
        """
        Update stats for the given server (picked from the server list)
        """
        # Get the server URI
        uri = self.__get_uri(server)

        # Try to connect to the server
        t = GlancesClientTransport()

The name t does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        t.set_timeout(3)

        # Get common stats
        try:
            s = ServerProxy(uri, transport=t)

The name s does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        except Exception as e:

Catching very general exceptions such as Exception is usually not recommended.

The name e does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            logger.warning(
                "Client browser couldn't create socket {}: {}".format(uri, e))

Use formatting in logging functions and pass the parameters as arguments

        else:
            # Mandatory stats
            try:
                # CPU%
                cpu_percent = 100 - json.loads(s.getCpu())['idle']
                server['cpu_percent'] = '{:.1f}'.format(cpu_percent)
                # MEM%
                server['mem_percent'] = json.loads(s.getMem())['percent']
                # OS (Human Readable name)
                server['hr_name'] = json.loads(s.getSystem())['hr_name']
            except (socket.error, Fault, KeyError) as e:

The name e does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                logger.debug(
                    "Error while grabbing stats form {}: {}".format(uri, e))

Use formatting in logging functions and pass the parameters as arguments

                server['status'] = 'OFFLINE'
            except ProtocolError as e:

The name e does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                if e.errcode == 401:
                    # Error 401 (Authentication failed)
                    # Password is not the good one...
                    server['password'] = None
                    server['status'] = 'PROTECTED'
                else:
                    server['status'] = 'OFFLINE'
                logger.debug("Cannot grab stats from {} ({} {})".format(uri, e.errcode, e.errmsg))

This line is too long as per the coding-style (98/80).

Use formatting in logging functions and pass the parameters as arguments

            else:
                # Status
                server['status'] = 'ONLINE'

                # Optional stats (load is not available on Windows OS)
                try:
                    # LOAD
                    load_min5 = json.loads(s.getLoad())['min5']
                    server['load_min5'] = '{:.2f}'.format(load_min5)
                except Exception as e:

Catching very general exceptions such as Exception is usually not recommended.

The name e does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                    logger.warning(
                        "Error while grabbing stats form {}: {}".format(uri, e))

Use formatting in logging functions and pass the parameters as arguments

        return server

    def __display_server(self, server):
        """
        Connect and display the given server
        """
        # Display the Glances client for the selected server
        logger.debug("Selected server {}".format(server))

Use formatting in logging functions and pass the parameters as arguments

        # Connection can take time
        # Display a popup
        self.screen.display_popup(
            'Connect to {}:{}'.format(server['name'], server['port']), duration=1)

This line is too long as per the coding-style (82/80).

        # A password is needed to access to the server's stats
        if server['password'] is None:
            # First of all, check if a password is available in the [passwords] section

This line is too long as per the coding-style (87/80).

            clear_password = self.password.get_password(server['name'])
            if (clear_password is None or self.get_servers_list()
                    [self.screen.active_server]['status'] == 'PROTECTED'):

Wrong continued indentation (remove 4 spaces).

                # Else, the password should be enter by the user
                # Display a popup to enter password
                clear_password = self.screen.display_popup(
                    'Password needed for {}: '.format(server['name']), is_input=True)

This line is too long as per the coding-style (85/80).

            # Store the password for the selected server
            if clear_password is not None:
                self.set_in_selected('password', self.password.sha256_hash(clear_password))

This line is too long as per the coding-style (91/80).

        # Display the Glance client on the selected server
        logger.info("Connect Glances client to the {} server".format(server['key']))

This line is too long as per the coding-style (84/80).

Use formatting in logging functions and pass the parameters as arguments

        # Init the client
        args_server = self.args

        # Overwrite connection setting
        args_server.client = server['ip']
        args_server.port = server['port']
        args_server.username = server['username']
        args_server.password = server['password']
        client = GlancesClient(config=self.config, args=args_server, return_to_browser=True)

This line is too long as per the coding-style (92/80).

        # Test if client and server are in the same major version
        if not client.login():
            self.screen.display_popup(
                "Sorry, cannot connect to '{}'\n"
                "See '{}' for more details".format(server['name'], LOG_FILENAME))

This line is too long as per the coding-style (81/80).

            # Set the ONLINE status for the selected server
            self.set_in_selected('status', 'OFFLINE')
        else:
            # Start the client loop
            # Return connection type: 'glances' or 'snmp'
            connection_type = client.serve_forever()

            try:
                logger.debug("Disconnect Glances client from the {} server".format(server['key']))

This line is too long as per the coding-style (98/80).

Use formatting in logging functions and pass the parameters as arguments

            except IndexError:
                # Server did not exist anymore
                pass
            else:
                # Set the ONLINE status for the selected server
                if connection_type == 'snmp':
                    self.set_in_selected('status', 'SNMP')
                else:
                    self.set_in_selected('status', 'ONLINE')

        # Return to the browser (no server selected)
        self.screen.active_server = None

    def __serve_forever(self):
        """Main client loop."""
        # No need to update the server list
        # It's done by the GlancesAutoDiscoverListener class (autodiscover.py)
        # Or define staticaly in the configuration file (module static_list.py)
        # For each server in the list, grab elementary stats (CPU, LOAD, MEM, OS...)

This line is too long as per the coding-style (84/80).

        thread_list = {}
        while self.screen.is_end == False:

Comparison to False should be 'not expr' or 'expr is False'

            logger.debug("Iter through the following server list: {}".format(self.get_servers_list()))

This line is too long as per the coding-style (102/80).

Use formatting in logging functions and pass the parameters as arguments

            for v in self.get_servers_list():

The name v does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                key = v["key"]
                thread = thread_list.get(key, None)
                if thread is None or thread.is_alive() == False:

Comparison to False should be 'not expr' or 'expr is False'

                    thread = threading.Thread(target=self.__update_stats, args=[v])

This line is too long as per the coding-style (83/80).

                    thread_list[key] = thread
                    thread.start()

            # Update the screen (list or Glances client)
            if self.screen.active_server is None:
                #  Display the Glances browser
                self.screen.update(self.get_servers_list())
            else:
                # Display the active server
                self.__display_server(self.get_servers_list()[self.screen.active_server])

This line is too long as per the coding-style (89/80).

        # exit key pressed
        for thread in thread_list.values():
            thread.join()

    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 set_in_selected(self, key, value):
        """Set the (key, value) for the selected server in the list."""
        # Static list then dynamic one
        if self.screen.active_server >= len(self.static_server.get_servers_list()):

This line is too long as per the coding-style (83/80).

            self.autodiscover_server.set_server(
                self.screen.active_server - len(self.static_server.get_servers_list()),

This line is too long as per the coding-style (87/80).

                key, value)
        else:
            self.static_server.set_server(self.screen.active_server, key, value)

    def end(self):
        """End of the client browser session."""
        self.screen.end()