Revize 6b5427e6

re #9422 Commented config_manager.py and main.py

client/src/config_manager.py

@@ -3 +3 @@
 
 
 class Config:
+    """This class holds the configuration values of the application.
+
+    It reads the configuration file passed in through the constructor
+    and stores the values into class variables.
+    """
 
     def __init__(self, filepath):
+        """Constructor of the class.
+
+        It instantiates the class, reads the configuration file,
+        and parses all sections defined in it.
+
+        :param filepath: path to the configuration file
+        """
+        # Create a new ConfigParser
         self.config = RawConfigParser()
+
+        # Try to parse the configuration file. If it fails,
+        # terminate the application.
         if not self.config.read(filepath):
             print(f"Failed to parse the config file {filepath}. Make sure you entered a valid path.")
             exit(1)
 
+        # Parse the 'usb detector' section.
         self._parse_usb_detector_section()
+
+        # Parse the 'server' section (API).
         self._parse_server_section()
+
+        # Parse the 'logger' section.
         self._parse_logger_section()
+
+        # Parse the 'cache' section.
         self._parse_cache_section()
 
     def _parse_usb_detector_section(self):
+        """Parse the 'usb detector' section of the configuration file.
+        """
         section_name = "usb_detector"
         self.scan_period_seconds = float(self.config[section_name]["scan_period_seconds"])
         self.connected_devices_filename = self.config[section_name]["connected_devices_filename"]
 
     def _parse_server_section(self):
+        """Parse the 'server' section of the configuration file.
+        """
         section_name = "server"
         self.server_url = self.config[section_name]["url"]
         self.server_port = self.config[section_name]["port"]
         self.server_endpoint = self.config[section_name]["end_point"]
 
     def _parse_logger_section(self):
+        """Parse the 'logger' section of the configuration file.
+        """
         section_name = "logger"
         self.logger_config_file = self.config[section_name]["config_file"]
 
     def _parse_cache_section(self):
+        """Parse the 'cache' section of the configuration file.
+        """
         section_name = "cache"
         self.cache_dir = self.config[section_name]["directory"]
         self.cache_max_entries = int(self.config[section_name]["max_entries"])

client/src/main.py

@@ -13 +13 @@
 
 
 def init_logging(app_config: Config):
+    """Initializes logging, api client, and usb detector.
+
+    The function checks whether the path to the logger configuration
+    file exists. The path is defined in the logger section of the
+    main configuration file. It also calls api_client_set_config and
+    usb_detector_set_config to initialize the application.
+
+    :param app_config: instance of Config (config manager)
+    """
+    # If the logger configuration file exists.
     if exists(app_config.logger_config_file):
+        # Initialize logging according to the logger config file.
         logging.config.fileConfig(fname=app_config.logger_config_file)
+
+        # Initialize the rest of the application.
         api_client_set_config(app_config)
         usb_detector_set_config(app_config)
     else:
+        # If the file does not exist, terminate the application.
         print(f"Cannot find logger configuration \"{app_config.logger_config_file}\"! Please specify valid a path or define a new one.")
         exit(1)
 
 
 if __name__ == "__main__":
+    """Main entry point of the application.
+    
+    The application expects one parameter to be passed it -
+    the path to the configuration file. The user can print out help
+    using the '-h' option.
+    """
+    # Make sure that there is only one running instance of this application.
     try:
         app_instance = singleton.SingleInstance()
     except singleton.SingleInstanceException:
         exit(1)
 
+    # Parse the arguments passed in from the command line.
     arg_parser = argparse.ArgumentParser(description="ZF USB License Detector")
     arg_parser.add_argument("-c", "--config", dest="config", required=True, help="Path to the configuration file")
     args = arg_parser.parse_args()
 
+    # Read the configuration file and initialize the application (logging).
     config = Config(args.config)
     init_logging(config)
 
+    # Register callbacks (connected/disconnected USB device).
     register_listener(callback=usb_connected_callback, connected=True)
     register_listener(callback=usb_disconnected_callback, connected=False)
 
+    # Create a thread for the USB detector.
     usb_detector_thread = Thread(target=usb_detector_run)
     usb_detector_thread.setDaemon(True)
 
+    # Create a thread for resending failed payloads to the server.
     api_thread = Thread(target=api_client_run)
     api_thread.setDaemon(True)
 
+    # Start the USB detector thread.
     logging.info("Starting USB detector.")
     usb_detector_thread.start()
 
+    # Start the API client thread.
     logging.info("Starting API communication manager.")
     api_thread.start()
 
+    # The execution should never get here as both
+    # threads are infinite loops.
     usb_detector_thread.join()
     api_thread.join()