Revize 9219c992

re #9420 Created folders src and resources; renamed config.ini to client.conf

client/api_client.py

@@ -1 @@
-import json
-import requests
-import logging
-from time import sleep
-from diskcache import Deque
-from requests import HTTPError, ConnectionError
-
-
-_uri = None
-_cache = None
-_config = None
-
-
-def api_client_set_config(config):
-    global _config, _cache, _uri
-    _config = config
-    _cache = Deque(directory=_config.cache_dir)
-    _uri = config.server_url + ":" + config.server_port + config.server_endpoint
-
-
-def send_data(payload: dict):
-    try:
-        logging.info(f"sending payload = {payload} to {_uri}")
-        response = requests.post(url=_uri, data=json.dumps(payload))
-        logging.info(f"response text: {response.text}")
-    except ConnectionError:
-        logging.warning(f"sending payload = {payload} to {_uri} failed")
-        _cache_failed_payload(payload)
-    except HTTPError as error:
-        logging.error(f"HTTP Error ({_uri}) payload = {payload}, {error}")
-        _cache_failed_payload(payload)
-
-
-def _cache_failed_payload(payload: dict):
-    if len(_cache) >= _config.cache_max_entries:
-        oldest_payload = _cache.pop()
-        logging.warning(f"cache is full - discarding payload = {oldest_payload}")
-
-    logging.info(f"adding payload = {payload} into cache")
-    _cache.append(payload)
-
-
-def _resend_cached_payloads():
-    retries = min(_config.cache_max_retries, len(_cache))
-    logging.info(f"emptying the cache ({retries} records)")
-    for _ in range(0, retries):
-        payload = _cache.pop()
-        send_data(payload)
-
-
-def api_client_run():
-    while True:
-        _resend_cached_payloads()
-        sleep(_config.cache_retry_period_seconds)

client/config.ini

@@ -1 @@
-[usb_detector]
-scan_period_seconds = 1
-connected_devices_filename = data/devices.json
-
-[server]
-url = http://127.0.0.1
-port = 8000
-end_point = /api/v1/usb-logs
-
-[logger]
-config_file = logger.conf
-
-[cache]
-directory = data
-max_entries = 100
-max_retries = 20
-retry_period_seconds = 20

client/config_manager.py

@@ -1 @@
-from sys import exit
-from configparser import RawConfigParser
-
-
-class Config:
-
-    def __init__(self, filepath):
-        self.config = RawConfigParser()
-        if not self.config.read(filepath):
-            print(f"Failed to parse the config file {filepath}. Make sure you entered a valid path.")
-            exit(1)
-
-        self._parse_usb_detector_section()
-        self._parse_server_section()
-        self._parse_logger_section()
-        self._parse_cache_section()
-
-    def _parse_usb_detector_section(self):
-        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):
-        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):
-        section_name = "logger"
-        self.logger_config_file = self.config[section_name]["config_file"]
-
-    def _parse_cache_section(self):
-        section_name = "cache"
-        self.cache_dir = self.config[section_name]["directory"]
-        self.cache_max_entries = int(self.config[section_name]["max_entries"])
-        self.cache_max_retries = int(self.config[section_name]["max_retries"])
-        self.cache_retry_period_seconds = float(self.config[section_name]["retry_period_seconds"])

client/logger.conf

@@ -1 @@
-[loggers]
-keys=root
-
-[handlers]
-keys=consoleHandler,logFileHandler
-
-[formatters]
-keys=simpleFormatter
-
-[logger_root]
-level=DEBUG
-handlers=consoleHandler
-
-[handler_consoleHandler]
-class=StreamHandler
-level=DEBUG
-formatter=simpleFormatter
-args=(sys.stdout,)
-
-[handler_logFileHandler]
-class=handlers.RotatingFileHandler
-level=NOTSET
-args=('log_file.log', 'a', 10485760, 1)
-formatter=simpleFormatter
-
-[formatter_simpleFormatter]
-format=%(asctime)s - %(levelname)s - %(message)s

client/main.py

@@ -1 @@
-import logging
-import logging.config
-import argparse
-from os.path import exists
-from threading import Thread
-from tendo import singleton
-from sys import exit
-
-from config_manager import Config
-from usb_detector.detector import register_listener, usb_detector_run, usb_detector_set_config
-from usb_detector.event_listener import usb_connected_callback, usb_disconnected_callback
-from api_client import api_client_run, api_client_set_config
-
-
-def init_logging(app_config: Config):
-    if exists(app_config.logger_config_file):
-        logging.config.fileConfig(fname=app_config.logger_config_file)
-        api_client_set_config(app_config)
-        usb_detector_set_config(app_config)
-    else:
-        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__":
-    try:
-        app_instance = singleton.SingleInstance()
-    except singleton.SingleInstanceException:
-        exit(1)
-
-    arg_parser = argparse.ArgumentParser(description="ZF USB Licence Detector")
-    arg_parser.add_argument("-c", "--config", dest="config", required=True, help="Path to the configuration file")
-    args = arg_parser.parse_args()
-
-    config = Config(args.config)
-    init_logging(config)
-
-    register_listener(callback=usb_connected_callback, connected=True)
-    register_listener(callback=usb_disconnected_callback, connected=False)
-
-    usb_detector_thread = Thread(target=usb_detector_run)
-    usb_detector_thread.setDaemon(True)
-
-    api_thread = Thread(target=api_client_run)
-    api_thread.setDaemon(True)
-
-    logging.info("Starting USB detector.")
-    usb_detector_thread.start()
-
-    logging.info("Starting API communication manager.")
-    api_thread.start()
-
-    usb_detector_thread.join()
-    api_thread.join()

client/resources/client.conf

@@ +1 @@
+[usb_detector]
+scan_period_seconds = 1
+connected_devices_filename = data/devices.json
+
+[server]
+url = http://127.0.0.1
+port = 8000
+end_point = /api/v1/usb-logs
+
+[logger]
+config_file = ../resources/logger.conf
+
+[cache]
+directory = data
+max_entries = 100
+max_retries = 20
+retry_period_seconds = 20

client/resources/logger.conf

@@ +1 @@
+[loggers]
+keys=root
+
+[handlers]
+keys=consoleHandler,logFileHandler
+
+[formatters]
+keys=simpleFormatter
+
+[logger_root]
+level=DEBUG
+handlers=consoleHandler
+
+[handler_consoleHandler]
+class=StreamHandler
+level=DEBUG
+formatter=simpleFormatter
+args=(sys.stdout,)
+
+[handler_logFileHandler]
+class=handlers.RotatingFileHandler
+level=NOTSET
+args=('log_file.log', 'a', 10485760, 1)
+formatter=simpleFormatter
+
+[formatter_simpleFormatter]
+format=%(asctime)s - %(levelname)s - %(message)s

client/src/api_client.py

@@ +1 @@
+import json
+import requests
+import logging
+from time import sleep
+from diskcache import Deque
+from requests import HTTPError, ConnectionError
+
+
+_uri = None
+_cache = None
+_config = None
+
+
+def api_client_set_config(config):
+    global _config, _cache, _uri
+    _config = config
+    _cache = Deque(directory=_config.cache_dir)
+    _uri = config.server_url + ":" + config.server_port + config.server_endpoint
+
+
+def send_data(payload: dict):
+    try:
+        logging.info(f"sending payload = {payload} to {_uri}")
+        response = requests.post(url=_uri, data=json.dumps(payload))
+        logging.info(f"response text: {response.text}")
+    except ConnectionError:
+        logging.warning(f"sending payload = {payload} to {_uri} failed")
+        _cache_failed_payload(payload)
+    except HTTPError as error:
+        logging.error(f"HTTP Error ({_uri}) payload = {payload}, {error}")
+        _cache_failed_payload(payload)
+
+
+def _cache_failed_payload(payload: dict):
+    if len(_cache) >= _config.cache_max_entries:
+        oldest_payload = _cache.pop()
+        logging.warning(f"cache is full - discarding payload = {oldest_payload}")
+
+    logging.info(f"adding payload = {payload} into cache")
+    _cache.append(payload)
+
+
+def _resend_cached_payloads():
+    retries = min(_config.cache_max_retries, len(_cache))
+    logging.info(f"emptying the cache ({retries} records)")
+    for _ in range(0, retries):
+        payload = _cache.pop()
+        send_data(payload)
+
+
+def api_client_run():
+    while True:
+        _resend_cached_payloads()
+        sleep(_config.cache_retry_period_seconds)

client/src/config_manager.py

@@ +1 @@
+from sys import exit
+from configparser import RawConfigParser
+
+
+class Config:
+
+    def __init__(self, filepath):
+        self.config = RawConfigParser()
+        if not self.config.read(filepath):
+            print(f"Failed to parse the config file {filepath}. Make sure you entered a valid path.")
+            exit(1)
+
+        self._parse_usb_detector_section()
+        self._parse_server_section()
+        self._parse_logger_section()
+        self._parse_cache_section()
+
+    def _parse_usb_detector_section(self):
+        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):
+        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):
+        section_name = "logger"
+        self.logger_config_file = self.config[section_name]["config_file"]
+
+    def _parse_cache_section(self):
+        section_name = "cache"
+        self.cache_dir = self.config[section_name]["directory"]
+        self.cache_max_entries = int(self.config[section_name]["max_entries"])
+        self.cache_max_retries = int(self.config[section_name]["max_retries"])
+        self.cache_retry_period_seconds = float(self.config[section_name]["retry_period_seconds"])

client/src/main.py

@@ +1 @@
+import logging
+import logging.config
+import argparse
+from os.path import exists
+from threading import Thread
+from tendo import singleton
+from sys import exit
+
+from config_manager import Config
+from usb_detector.detector import register_listener, usb_detector_run, usb_detector_set_config
+from usb_detector.event_listener import usb_connected_callback, usb_disconnected_callback
+from api_client import api_client_run, api_client_set_config
+
+
+def init_logging(app_config: Config):
+    if exists(app_config.logger_config_file):
+        logging.config.fileConfig(fname=app_config.logger_config_file)
+        api_client_set_config(app_config)
+        usb_detector_set_config(app_config)
+    else:
+        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__":
+    try:
+        app_instance = singleton.SingleInstance()
+    except singleton.SingleInstanceException:
+        exit(1)
+
+    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()
+
+    config = Config(args.config)
+    init_logging(config)
+
+    register_listener(callback=usb_connected_callback, connected=True)
+    register_listener(callback=usb_disconnected_callback, connected=False)
+
+    usb_detector_thread = Thread(target=usb_detector_run)
+    usb_detector_thread.setDaemon(True)
+
+    api_thread = Thread(target=api_client_run)
+    api_thread.setDaemon(True)
+
+    logging.info("Starting USB detector.")
+    usb_detector_thread.start()
+
+    logging.info("Starting API communication manager.")
+    api_thread.start()
+
+    usb_detector_thread.join()
+    api_thread.join()

client/src/usb_detector/detector.py

@@ +1 @@
+import json
+import logging
+from time import sleep
+
+from .usb_reader import read_connected_devices
+
+
+_listeners_connected = []
+_listeners_disconnected = []
+_last_connected_devices = []
+_config = None
+
+
+def usb_detector_set_config(config):
+    global _config
+    _config = config
+
+
+def register_listener(callback, connected: bool = True):
+    logging.info(f"Registering callback: {callback}.")
+    if connected is True:
+        _listeners_connected.append(callback)
+    else:
+        _listeners_disconnected.append(callback)
+
+
+def _notify_listeners(listeners: list, devices: list):
+    if listeners is None or devices is None:
+        return
+    for callback in listeners:
+        for device in devices:
+            callback(device)
+
+
+def _store_connected_devices(devices: list):
+    logging.debug("storing newly connected devices")
+    with open(_config.connected_devices_filename, "w") as file:
+        json.dump(devices, file)
+
+
+def _load_last_connected_devices() -> list:
+    logging.debug("loading last connected devices")
+    try:
+        with open(_config.connected_devices_filename, "r") as file:
+            return json.loads(file.read())
+    except IOError:
+        logging.error("loading of last connected devices failed")
+        return []
+
+
+def _get_connected_devices(detected_devices: list, last_connected_devices: list) -> list:
+    return [device for device in detected_devices if device not in last_connected_devices]
+
+
+def _get_disconnected_devices(detected_devices: list, last_connected_devices: list) -> list:
+    return [device for device in last_connected_devices if device not in detected_devices]
+
+
+def _update():
+    global _last_connected_devices
+    detected_devices = read_connected_devices()
+
+    connected_devices = _get_connected_devices(detected_devices, _last_connected_devices)
+    disconnected_devices = _get_disconnected_devices(detected_devices, _last_connected_devices)
+
+    _notify_listeners(_listeners_connected, connected_devices)
+    _notify_listeners(_listeners_disconnected, disconnected_devices)
+
+    if len(connected_devices) > 0 or len(disconnected_devices) > 0:
+        _store_connected_devices(detected_devices)
+        _last_connected_devices = detected_devices
+
+
+def usb_detector_run():
+    logging.info("USB device detector is now running")
+
+    global _last_connected_devices
+    _last_connected_devices = _load_last_connected_devices()
+
+    while True:
+        _update()
+        sleep(_config.scan_period_seconds)

client/src/usb_detector/event_listener.py

@@ +1 @@
+import platform
+import logging
+import getpass
+from datetime import datetime
+
+from api_client import send_data
+
+
+def _get_metadata() -> dict:
+    logging.debug("getting computer metadata")
+    return {
+        "username": getpass.getuser(),
+        "hostname": platform.uname().node,
+        "timestamp": str(datetime.now())
+    }
+
+
+def _send_payload_to_server(device: dict, status: str):
+    logging.debug("payload send preparation")
+    payload = _get_metadata()
+    payload["device"] = device
+    payload["status"] = status
+    send_data(payload)
+
+
+def usb_connected_callback(device: dict):
+    logging.info(f"Device {device} has been connected")
+    _send_payload_to_server(device, "connected")
+
+
+def usb_disconnected_callback(device: dict):
+    logging.info(f"Device {device} has been disconnected")
+    _send_payload_to_server(device, "disconnected")

client/src/usb_detector/usb_reader.py

@@ +1 @@
+import logging
+
+import usb.core
+import usb.util
+
+
+_invalid_devices = []
+
+
+def read_connected_devices():
+    logging.debug("reading all currently connected devices")
+    detected_devices = []
+
+    busses = usb.busses()
+
+    for bus in busses:
+        devices = bus.devices
+        for dev in devices:
+            device = {
+                "vendor_id": dev.idVendor,
+                "product_id": dev.idProduct
+            }
+            serial_number = None
+            device_info = usb.core.find(idProduct=dev.idProduct)
+            try:
+                serial_number = usb.util.get_string(device_info, device_info.iSerialNumber)
+            except ValueError:
+                if device not in _invalid_devices:
+                    logging.warning(f"Could not retrieve serial number from device {device}")
+                    _invalid_devices.append(device)
+
+            if serial_number is not None:
+                if device in _invalid_devices:
+                    _invalid_devices.remove(device)
+
+                device["serial_number"] = serial_number
+                detected_devices.append(device)
+
+    return detected_devices

client/usb_detector/detector.py

@@ -1 @@
-import json
-import logging
-from time import sleep
-
-from .usb_reader import read_connected_devices
-
-
-_listeners_connected = []
-_listeners_disconnected = []
-_last_connected_devices = []
-_config = None
-
-
-def usb_detector_set_config(config):
-    global _config
-    _config = config
-
-
-def register_listener(callback, connected: bool = True):
-    logging.info(f"Registering callback: {callback}.")
-    if connected is True:
-        _listeners_connected.append(callback)
-    else:
-        _listeners_disconnected.append(callback)
-
-
-def _notify_listeners(listeners: list, devices: list):
-    if listeners is None or devices is None:
-        return
-    for callback in listeners:
-        for device in devices:
-            callback(device)
-
-
-def _store_connected_devices(devices: list):
-    logging.debug("storing newly connected devices")
-    with open(_config.connected_devices_filename, "w") as file:
-        json.dump(devices, file)
-
-
-def _load_last_connected_devices() -> list:
-    logging.debug("loading last connected devices")
-    try:
-        with open(_config.connected_devices_filename, "r") as file:
-            return json.loads(file.read())
-    except IOError:
-        logging.error("loading of last connected devices failed")
-        return []
-
-
-def _get_connected_devices(detected_devices: list, last_connected_devices: list) -> list:
-    return [device for device in detected_devices if device not in last_connected_devices]
-
-
-def _get_disconnected_devices(detected_devices: list, last_connected_devices: list) -> list:
-    return [device for device in last_connected_devices if device not in detected_devices]
-
-
-def _update():
-    global _last_connected_devices
-    detected_devices = read_connected_devices()
-
-    connected_devices = _get_connected_devices(detected_devices, _last_connected_devices)
-    disconnected_devices = _get_disconnected_devices(detected_devices, _last_connected_devices)
-
-    _notify_listeners(_listeners_connected, connected_devices)
-    _notify_listeners(_listeners_disconnected, disconnected_devices)
-
-    if len(connected_devices) > 0 or len(disconnected_devices) > 0:
-        _store_connected_devices(detected_devices)
-        _last_connected_devices = detected_devices
-
-
-def usb_detector_run():
-    logging.info("USB device detector is now running")
-
-    global _last_connected_devices
-    _last_connected_devices = _load_last_connected_devices()
-
-    while True:
-        _update()
-        sleep(_config.scan_period_seconds)

client/usb_detector/event_listener.py

@@ -1 @@
-import platform
-import logging
-import getpass
-from datetime import datetime
-
-from api_client import send_data
-
-
-def _get_metadata() -> dict:
-    logging.debug("getting computer metadata")
-    return {
-        "username": getpass.getuser(),
-        "hostname": platform.uname().node,
-        "timestamp": str(datetime.now())
-    }
-
-
-def _send_payload_to_server(device: dict, status: str):
-    logging.debug("payload send preparation")
-    payload = _get_metadata()
-    payload["device"] = device
-    payload["status"] = status
-    send_data(payload)
-
-
-def usb_connected_callback(device: dict):
-    logging.info(f"Device {device} has been connected")
-    _send_payload_to_server(device, "connected")
-
-
-def usb_disconnected_callback(device: dict):
-    logging.info(f"Device {device} has been disconnected")
-    _send_payload_to_server(device, "disconnected")

client/usb_detector/usb_reader.py

@@ -1 @@
-import logging
-
-import usb.core
-import usb.util
-
-
-_invalid_devices = []
-
-
-def read_connected_devices():
-    logging.debug("reading all currently connected devices")
-    detected_devices = []
-
-    busses = usb.busses()
-
-    for bus in busses:
-        devices = bus.devices
-        for dev in devices:
-            device = {
-                "vendor_id": dev.idVendor,
-                "product_id": dev.idProduct
-            }
-            serial_number = None
-            device_info = usb.core.find(idProduct=dev.idProduct)
-            try:
-                serial_number = usb.util.get_string(device_info, device_info.iSerialNumber)
-            except ValueError:
-                if device not in _invalid_devices:
-                    logging.warning(f"Could not retrieve serial number from device {device}")
-                    _invalid_devices.append(device)
-
-            if serial_number is not None:
-                if device in _invalid_devices:
-                    _invalid_devices.remove(device)
-
-                device["serial_number"] = serial_number
-                detected_devices.append(device)
-
-    return detected_devices