LinuxMonitor 1.1.1__tar.gz → 1.2.0__tar.gz

{linuxmonitor-1.1.1 → linuxmonitor-1.2.0/LinuxMonitor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LinuxMonitor
-Version: 1.1.1
+Version: 1.2.0
 Summary: Get information and warning status of Linux server like service, port, ping, ssl certificate, disk/folder/cpu/ram/swap usage, ip connection, ... (Python and shell library, Linux ONLY)
 Home-page: https://github.com/QuentinCG/Linux-Monitor-Python-Library
 Author: Quentin Comte-Gaz
@@ -49,6 +49,7 @@ List of 'check' functionalities:
   - Check disk usage
   - Check folder usage
   - Check websites basic availability (ping)
+  - Check websites access with optional authentication (GET request)
   - Check services status and restart them if needed
   - Check certificates expiration and validity
   - Check last user connections IPs
@@ -102,46 +103,49 @@ python3 -m linuxmonitor --start_scheduled_task_show_info --config_file config-ex
 
 
 # View disk space, CPU, RAM, ...
-python3 -m linuxmonitor --usage --config_file config-example.json
+python3 -m linuxmonitor --usage --config_file config-example.json --nodebug
 
 # View basic system information
-python3 -m linuxmonitor --os_infos --config_file config-example.json
+python3 -m linuxmonitor --os_infos --config_file config-example.json --nodebug
 
 # View connected users
-python3 -m linuxmonitor --users --config_file config-example.json
+python3 -m linuxmonitor --users --config_file config-example.json --nodebug
 
 # View last user connections
-python3 -m linuxmonitor --user_logins --config_file config-example.json
+python3 -m linuxmonitor --user_logins --config_file config-example.json --nodebug
 
 # Check websites (ping)
-python3 -m linuxmonitor --ping --config_file config-example.json
+python3 -m linuxmonitor --ping --config_file config-example.json --nodebug
+
+# Check websites access with optional authentication (GET request)
+python3 -m linuxmonitor --websites --config_file config-example.json --nodebug
 
 # Check SSL certificates
-python3 -m linuxmonitor --certificates --config_file config-example.json
+python3 -m linuxmonitor --certificates --config_file config-example.json --nodebug
 
 # Check if services are running and restart if down
-python3 -m linuxmonitor --services_status --config_file config-example.json
+python3 -m linuxmonitor --services_status --config_file config-example.json --nodebug
 
 # List all available services
-python3 -m linuxmonitor --list_services --config_file config-example.json
+python3 -m linuxmonitor --list_services --config_file config-example.json --nodebug
 
 # Restart all services
-python3 -m linuxmonitor --restart_all --config_file config-example.json
+python3 -m linuxmonitor --restart_all --config_file config-example.json --nodebug
 
 # Restart a service
-python3 -m linuxmonitor --restart_service SERVICE_NAME_HERE --config_file config-example.json
+python3 -m linuxmonitor --restart_service SERVICE_NAME_HERE --config_file config-example.json --nodebug
 
 # Check ports
-python3 -m linuxmonitor --ports --config_file config-example.json
+python3 -m linuxmonitor --ports --config_file config-example.json --nodebug
 
 # List active processes
-python3 -m linuxmonitor --list_processes --config_file config-example.json
+python3 -m linuxmonitor --list_processes --config_file config-example.json --nodebug
 
 # Stop a process by PID
-python3 -m linuxmonitor --kill_process PID_HERE --config_file config-example.json
+python3 -m linuxmonitor --kill_process PID_HERE --config_file config-example.json --nodebug
 
 # Restart the entire server
-python3 -m linuxmonitor --reboot_server --config_file config-example.json
+python3 -m linuxmonitor --reboot_server --config_file config-example.json --nodebug
 ```
 
 ## How to use in python script

{linuxmonitor-1.1.1/LinuxMonitor.egg-info → linuxmonitor-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LinuxMonitor
-Version: 1.1.1
+Version: 1.2.0
 Summary: Get information and warning status of Linux server like service, port, ping, ssl certificate, disk/folder/cpu/ram/swap usage, ip connection, ... (Python and shell library, Linux ONLY)
 Home-page: https://github.com/QuentinCG/Linux-Monitor-Python-Library
 Author: Quentin Comte-Gaz
@@ -49,6 +49,7 @@ List of 'check' functionalities:
   - Check disk usage
   - Check folder usage
   - Check websites basic availability (ping)
+  - Check websites access with optional authentication (GET request)
   - Check services status and restart them if needed
   - Check certificates expiration and validity
   - Check last user connections IPs
@@ -102,46 +103,49 @@ python3 -m linuxmonitor --start_scheduled_task_show_info --config_file config-ex
 
 
 # View disk space, CPU, RAM, ...
-python3 -m linuxmonitor --usage --config_file config-example.json
+python3 -m linuxmonitor --usage --config_file config-example.json --nodebug
 
 # View basic system information
-python3 -m linuxmonitor --os_infos --config_file config-example.json
+python3 -m linuxmonitor --os_infos --config_file config-example.json --nodebug
 
 # View connected users
-python3 -m linuxmonitor --users --config_file config-example.json
+python3 -m linuxmonitor --users --config_file config-example.json --nodebug
 
 # View last user connections
-python3 -m linuxmonitor --user_logins --config_file config-example.json
+python3 -m linuxmonitor --user_logins --config_file config-example.json --nodebug
 
 # Check websites (ping)
-python3 -m linuxmonitor --ping --config_file config-example.json
+python3 -m linuxmonitor --ping --config_file config-example.json --nodebug
+
+# Check websites access with optional authentication (GET request)
+python3 -m linuxmonitor --websites --config_file config-example.json --nodebug
 
 # Check SSL certificates
-python3 -m linuxmonitor --certificates --config_file config-example.json
+python3 -m linuxmonitor --certificates --config_file config-example.json --nodebug
 
 # Check if services are running and restart if down
-python3 -m linuxmonitor --services_status --config_file config-example.json
+python3 -m linuxmonitor --services_status --config_file config-example.json --nodebug
 
 # List all available services
-python3 -m linuxmonitor --list_services --config_file config-example.json
+python3 -m linuxmonitor --list_services --config_file config-example.json --nodebug
 
 # Restart all services
-python3 -m linuxmonitor --restart_all --config_file config-example.json
+python3 -m linuxmonitor --restart_all --config_file config-example.json --nodebug
 
 # Restart a service
-python3 -m linuxmonitor --restart_service SERVICE_NAME_HERE --config_file config-example.json
+python3 -m linuxmonitor --restart_service SERVICE_NAME_HERE --config_file config-example.json --nodebug
 
 # Check ports
-python3 -m linuxmonitor --ports --config_file config-example.json
+python3 -m linuxmonitor --ports --config_file config-example.json --nodebug
 
 # List active processes
-python3 -m linuxmonitor --list_processes --config_file config-example.json
+python3 -m linuxmonitor --list_processes --config_file config-example.json --nodebug
 
 # Stop a process by PID
-python3 -m linuxmonitor --kill_process PID_HERE --config_file config-example.json
+python3 -m linuxmonitor --kill_process PID_HERE --config_file config-example.json --nodebug
 
 # Restart the entire server
-python3 -m linuxmonitor --reboot_server --config_file config-example.json
+python3 -m linuxmonitor --reboot_server --config_file config-example.json --nodebug
 ```
 
 ## How to use in python script

{linuxmonitor-1.1.1 → linuxmonitor-1.2.0}/README.md

@@ -21,6 +21,7 @@ List of 'check' functionalities:
   - Check disk usage
   - Check folder usage
   - Check websites basic availability (ping)
+  - Check websites access with optional authentication (GET request)
   - Check services status and restart them if needed
   - Check certificates expiration and validity
   - Check last user connections IPs
@@ -74,46 +75,49 @@ python3 -m linuxmonitor --start_scheduled_task_show_info --config_file config-ex
 
 
 # View disk space, CPU, RAM, ...
-python3 -m linuxmonitor --usage --config_file config-example.json
+python3 -m linuxmonitor --usage --config_file config-example.json --nodebug
 
 # View basic system information
-python3 -m linuxmonitor --os_infos --config_file config-example.json
+python3 -m linuxmonitor --os_infos --config_file config-example.json --nodebug
 
 # View connected users
-python3 -m linuxmonitor --users --config_file config-example.json
+python3 -m linuxmonitor --users --config_file config-example.json --nodebug
 
 # View last user connections
-python3 -m linuxmonitor --user_logins --config_file config-example.json
+python3 -m linuxmonitor --user_logins --config_file config-example.json --nodebug
 
 # Check websites (ping)
-python3 -m linuxmonitor --ping --config_file config-example.json
+python3 -m linuxmonitor --ping --config_file config-example.json --nodebug
+
+# Check websites access with optional authentication (GET request)
+python3 -m linuxmonitor --websites --config_file config-example.json --nodebug
 
 # Check SSL certificates
-python3 -m linuxmonitor --certificates --config_file config-example.json
+python3 -m linuxmonitor --certificates --config_file config-example.json --nodebug
 
 # Check if services are running and restart if down
-python3 -m linuxmonitor --services_status --config_file config-example.json
+python3 -m linuxmonitor --services_status --config_file config-example.json --nodebug
 
 # List all available services
-python3 -m linuxmonitor --list_services --config_file config-example.json
+python3 -m linuxmonitor --list_services --config_file config-example.json --nodebug
 
 # Restart all services
-python3 -m linuxmonitor --restart_all --config_file config-example.json
+python3 -m linuxmonitor --restart_all --config_file config-example.json --nodebug
 
 # Restart a service
-python3 -m linuxmonitor --restart_service SERVICE_NAME_HERE --config_file config-example.json
+python3 -m linuxmonitor --restart_service SERVICE_NAME_HERE --config_file config-example.json --nodebug
 
 # Check ports
-python3 -m linuxmonitor --ports --config_file config-example.json
+python3 -m linuxmonitor --ports --config_file config-example.json --nodebug
 
 # List active processes
-python3 -m linuxmonitor --list_processes --config_file config-example.json
+python3 -m linuxmonitor --list_processes --config_file config-example.json --nodebug
 
 # Stop a process by PID
-python3 -m linuxmonitor --kill_process PID_HERE --config_file config-example.json
+python3 -m linuxmonitor --kill_process PID_HERE --config_file config-example.json --nodebug
 
 # Restart the entire server
-python3 -m linuxmonitor --reboot_server --config_file config-example.json
+python3 -m linuxmonitor --reboot_server --config_file config-example.json --nodebug
 ```
 
 ## How to use in python script

{linuxmonitor-1.1.1 → linuxmonitor-1.2.0}/linuxmonitor/__main__.py

@@ -17,6 +17,7 @@ def main() -> None:
     parser.add_argument('--users', action='store_true', help='👥 View connected users 👥')
     parser.add_argument('--user_logins', action='store_true', help='👥 View last user connections 👥')
     parser.add_argument('--ping', action='store_true', help='🌐 Ping websites 🌐')
+    parser.add_argument('--websites', action='store_true', help='🌐 Check websites access (GET requests) 🌐')
     parser.add_argument('--certificates', action='store_true', help='🔒 Check SSL certificates 🔒')
     parser.add_argument('--reboot_server', action='store_true', help='🔄 Restart the entire server 🔄')
     parser.add_argument('--services_status', action='store_true', help='🩺 Check services are running 🩺')
@@ -98,7 +99,13 @@ def main() -> None:
     if args.ping:
         handled = True
         print("Pinging websites...")
-        out_msg: str = monitoring.ping_all_websites(is_private=True, display_only_if_critical=False)
+        out_msg: str = asyncio.run(monitoring.ping_all_websites(is_private=True, display_only_if_critical=False))
+        print(out_msg)
+
+    if args.websites:
+        handled = True
+        print("Checking websites availability...")
+        out_msg: str = asyncio.run(monitoring.check_all_websites(is_private=True, display_only_if_critical=False))
         print(out_msg)
 
     if args.certificates:
@@ -110,24 +117,24 @@ def main() -> None:
     if args.reboot_server:
         handled = True
         print("Restarting the entire server...")
-        out_msg: str = monitoring.reboot_server()
+        out_msg: str = asyncio.run(monitoring.reboot_server())
         print(out_msg)
 
     if args.services_status:
         handled = True
         print("Checking if services are running and restart if down...")
-        out_msg: str = monitoring.check_all_services_status_and_restart_if_down(is_private=True)
+        out_msg: str = asyncio.run(monitoring.check_all_services_status_and_restart_if_down(is_private=True))
         print(out_msg)
 
     if args.restart_all:
         handled = True
         print("Restarting all services...")
-        out_msg: str = monitoring.restart_all_services(is_private=True)
+        out_msg: str = asyncio.run(monitoring.restart_all_services(is_private=True))
 
     if args.restart_service is not None:
         handled = True
         print(f"Restarting service: {args.restart_service}...")
-        out_msg: str = monitoring.restart_service(is_private=True, service_name=args.restart_service)
+        out_msg: str = asyncio.run(monitoring.restart_service(is_private=True, service_name=args.restart_service))
         print(out_msg)
 
     if args.list_services:
@@ -139,7 +146,7 @@ def main() -> None:
     if args.ports:
         handled = True
         print("Checking ports...")
-        out_msg: str = monitoring.check_all_ports(is_private=True, display_only_if_critical=False, restart_if_down=False)
+        out_msg: str = asyncio.run(monitoring.check_all_ports(is_private=True, display_only_if_critical=False, restart_if_down=False))
         print(out_msg)
 
     if args.list_processes:
@@ -151,7 +158,7 @@ def main() -> None:
     if args.kill_process is not None:
         handled = True
         print(f"Stopping process with PID: {args.kill_process}...")
-        out_msg: str = monitoring.kill_process(pid=args.kill_process)
+        out_msg: str = asyncio.run(monitoring.kill_process(pid=args.kill_process))
         print(out_msg)
 
     if args.start_scheduled_task_check_for_issues:

{linuxmonitor-1.1.1 → linuxmonitor-1.2.0}/linuxmonitor/linuxmonitor.py

@@ -10,6 +10,7 @@ Non exhaustive list of features (available by using it in shell or in python scr
     - Check disk usage
     - Check folder usage
     - Check websites basic availability (ping)
+    - Check websites access with optional authentication (GET request)
     - Check services status and restart them if needed
     - Check certificates expiration and validity
     - Check last user connections IPs
@@ -29,7 +30,7 @@ __email__ = "quentin@comte-gaz.com"
 __license__ = "MIT License"
 __copyright__ = "Copyright Quentin Comte-Gaz (2024)"
 __python_version__ = "3.+"
-__version__ = "1.1.1 (2024/09/14)"
+__version__ = "1.2.0 (2024/09/16)"
 __status__ = "Usable for any Linux project"
 
 import json
@@ -46,6 +47,8 @@ import platform
 import re
 import logging
 import asyncio
+from http.client import responses
+import aiohttp
 
 class LinuxMonitor:
     def __init__(self, config_file: str, allow_scheduled_tasks_check_for_issues: bool, allow_scheduled_task_show_info: bool) -> None:
@@ -92,6 +95,8 @@ class LinuxMonitor:
             raise ValueError("The configuration must contain the 'services' key")
         if 'certificates' not in self.config: # type: ignore
             raise ValueError("The configuration must contain the 'certificates' key")
+        if 'websites' not in self.config: # type: ignore
+            raise ValueError("The configuration must contain the 'websites' key")
 
         # Get the basic configuration (check if it is a dictionary)
         basic_config: Dict[str, Any] = self.config.get('basic_config', {}) # type: ignore
@@ -174,9 +179,9 @@ class LinuxMonitor:
 
     #region Execute Command
 
-    def execute_and_verify(self, command: List[str], display_name: str, timeout_in_sec: Optional[int] = None, display_only_if_critical: bool = False, check_also_stdout_not_containing: Optional[str] = None) -> Tuple[Optional[bool], str]:
+    async def execute_and_verify(self, command: List[str], display_name: str, timeout_in_sec: Optional[int] = None, display_only_if_critical: bool = False, check_also_stdout_not_containing: Optional[str] = None) -> Tuple[Optional[bool], str]:
         """
-        Execute a shell command and verify its correct execution.
+        Execute a shell command asynchronously and verify its correct execution.
 
         :param command: A list of strings representing the command and its arguments.
         :param display_name: The name of the command to display in the output message.
@@ -186,18 +191,24 @@ class LinuxMonitor:
 
         :return: A tuple containing a boolean indicating if the command was executed successfully and a string containing the result message.
         """
-        returncode: int = -1
+        returncode: Optional[int] = None
 
         try:
             logging.debug(msg=f"Executing command {display_name} (command: {command})...")
-            pipe = subprocess.Popen(args=command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
+            process = await asyncio.create_subprocess_exec(
+                *command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                shell=False
+            )
+
             try:
-                stdout, stderr = pipe.communicate(timeout=timeout_in_sec)
-                returncode = pipe.returncode
-            except subprocess.TimeoutExpired:
+                stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout_in_sec)
+                returncode = process.returncode
+            except asyncio.TimeoutError:
                 logging.warning(msg=f"Timeout expired for {display_name} (command: {command})")
-                pipe.kill()
-                stdout, stderr = pipe.communicate()
+                process.kill()
+                return None, f"⚠️ **Error {display_name}**:\n- Failed to execute the command in less than {timeout_in_sec} seconds)"
         except Exception as e:
             # Failed to execute the command
             out_msg = f"⚠️ **Error {display_name}**:\n```sh\n{e}\n```"
@@ -209,7 +220,7 @@ class LinuxMonitor:
         stderr_str: str = stderr.decode(encoding='utf-8').replace('`', '"').strip()
 
         # Check if the command executed successfully
-        res: Optional[bool] = (returncode == 0) if (returncode != -1) else None
+        res: Optional[bool] = (returncode == 0) if (returncode != None) else None
         if res and check_also_stdout_not_containing:
             res = check_also_stdout_not_containing not in stdout_str
 
@@ -244,7 +255,7 @@ class LinuxMonitor:
 
     #region Reboot
 
-    def reboot_server(self) -> str:
+    async def reboot_server(self) -> str:
         """
         Reboot the server.
 
@@ -253,7 +264,7 @@ class LinuxMonitor:
         IMPORTANT: To be usable, the user must have the right to execute `sudo /sbin/reboot` command without password.
         """
         logging.info(msg="Rebooting the server...")
-        _, out_msg = self.execute_and_verify(command=["sudo", "/sbin/reboot"], display_name="Server reboot", timeout_in_sec=None, display_only_if_critical=False)
+        _, out_msg = await self.execute_and_verify(command=["sudo", "/sbin/reboot"], display_name="Server reboot", timeout_in_sec=None, display_only_if_critical=False)
         return out_msg
 
     #endregion
@@ -721,7 +732,7 @@ class LinuxMonitor:
 
     #region Ping Websites
 
-    def _ping_website(self, website: str, display_name: str, timeout_in_sec: int, display_only_if_critical: bool=False) -> str:
+    async def _ping_website(self, website: str, display_name: str, timeout_in_sec: int, display_only_if_critical: bool=False) -> str:
         """
         Ping a website.
 
@@ -731,21 +742,26 @@ class LinuxMonitor:
 
         :return: A string containing the result message.
         """
-        ping_command: list[str] = ["ping", "-c", "1", website]
-        display_name = f"[{display_name}](https://{website})"
+        try:
+            ping_command: list[str] = ["ping", "-c", "1", website]
+            display_name = f"[{display_name}](https://{website})"
 
-        start_time: float = time.time()
-        res, out_msg = self.execute_and_verify(command=ping_command, display_name=f"ping {display_name}", timeout_in_sec=timeout_in_sec, display_only_if_critical=display_only_if_critical)
-        end_time: float = time.time()
+            start_time: float = time.time()
+            res, out_msg = await self.execute_and_verify(command=ping_command, display_name=f"ping {display_name}", timeout_in_sec=timeout_in_sec, display_only_if_critical=display_only_if_critical)
+            end_time: float = time.time()
 
-        if res == True and not display_only_if_critical:
-            res_ping_sec: str = "{:.2f}sec".format(end_time - start_time)
-            out_msg: str = f"✅ **{display_name} answered in {res_ping_sec}**."
-            logging.info(msg=out_msg)
+            if res == True and not display_only_if_critical:
+                res_ping_sec: str = "{:.2f}sec".format(end_time - start_time)
+                out_msg: str = f"✅ **{display_name} answered in {res_ping_sec}**."
+                logging.info(msg=out_msg)
 
-        return out_msg
+            return out_msg
+        except Exception as e:
+            out_msg = f"⚠️ **Error pinging {display_name}**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            return out_msg
 
-    def ping_all_websites(self, is_private: bool, display_only_if_critical: bool=False) -> str:
+    async def ping_all_websites(self, is_private: bool, display_only_if_critical: bool=False) -> str:
         """
         Ping all websites configured in the JSON configuration file.
 
@@ -758,7 +774,7 @@ class LinuxMonitor:
         for ping_config in self.config['pings']:
             if is_private or is_private == ping_config['is_private']:
                 timeout_in_sec: int = ping_config.get('timeout_in_sec', 5)
-                result: str = self._ping_website(website=ping_config['website'], display_name=ping_config['display_name'], timeout_in_sec=timeout_in_sec, display_only_if_critical=display_only_if_critical)
+                result: str = await self._ping_website(website=ping_config['website'], display_name=ping_config['display_name'], timeout_in_sec=timeout_in_sec, display_only_if_critical=display_only_if_critical)
                 if result:
                     if out_msg:
                         out_msg += "\n"
@@ -771,6 +787,87 @@ class LinuxMonitor:
 
     #endregion
 
+    #region Check website response
+
+    async def _check_website(self, url: str, display_name: str, timeout_in_sec: int = 5, auth_type: Optional[str] = None, username: Optional[str] = None, password: Optional[str] = None, token: Optional[str] = None, additional_allowed_statuses: List[int] = [], display_only_if_critical: bool=False) -> Tuple[bool, str]:
+        try:
+            display_name = f"[{display_name}]({url})"
+
+            auth = None
+            headers: Dict[str, str] = {}
+
+            # Select the appropriate authentication method
+            if auth_type == 'basic' and username and password:
+                auth = aiohttp.BasicAuth(username, password)  # Use aiohttp.BasicAuth for basic authentication
+            elif auth_type == 'digest' and username and password:
+                return False, f"❌ **Digest authentication not supported, cannot check {display_name}**."
+            elif auth_type == 'bearer' and token:
+                headers = {'Authorization': f'Bearer {token}'}
+
+            # Create an aiohttp client session to make the request
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, auth=auth, headers=headers, timeout=timeout_in_sec) as response:
+                    # Default allowed status codes (200-299)
+                    allowed_statuses = list(range(200, 300))
+
+                    # Include any additional allowed status codes if provided
+                    if additional_allowed_statuses:
+                        allowed_statuses += additional_allowed_statuses
+
+                    # Check if the status code is within the allowed list
+                    if response.status in allowed_statuses:
+                        out_msg: str = f"✅ **{display_name} answered with valid status code {response.status}**."
+                        logging.info(msg=out_msg)
+                        return True, out_msg
+                    else:
+                        # Get the reason phrase (e.g., "Unauthorized" for 401)
+                        status_reason: str = responses.get(response.status, "Unknown status")
+                        out_msg = f"❌ **{display_name} answered with invalid status code {response.status} - {status_reason}**."
+                        logging.warning(msg=out_msg)
+                        return False, out_msg
+
+        except asyncio.TimeoutError:
+            out_msg = f"⚠️ **Error checking {display_name}: Timeout**"
+            return False, out_msg
+        except Exception as e:
+            out_msg = f"⚠️ **Error checking {display_name}**:\n```sh\n{e}\n```"
+            return False, out_msg
+
+    async def check_all_websites(self, is_private: bool, display_only_if_critical: bool=False) -> str:
+        try:
+            out_msg: str = ""
+            for website_config in self.config['websites']:
+                if is_private or is_private == website_config['is_private']:
+                    timeout_in_sec: int = website_config.get('timeout_in_sec', 5)
+                    url: str = website_config['url']
+                    display_name: str = website_config.get('display_name', url)
+                    auth_type: Optional[str] = website_config.get('auth_type', None)
+                    username: Optional[str] = website_config.get('username', None)
+                    password: Optional[str] = website_config.get('password', None)
+                    token: Optional[str] = website_config.get('token', None)
+                    additional_allowed_statuses: List[int] = website_config.get('additional_allowed_statuses', [])
+
+                    _, msg = await self._check_website(url=url, display_name=display_name, timeout_in_sec=timeout_in_sec,
+                                                                  auth_type=auth_type, username=username, password=password, token=token,
+                                                                  additional_allowed_statuses=additional_allowed_statuses,
+                                                                  display_only_if_critical=display_only_if_critical)
+
+                    if msg != "":
+                        if out_msg:
+                            out_msg += "\n"
+                        out_msg += f"- {msg}"
+
+            if out_msg != "":
+                out_msg = f"# 🌐 Website access state 🌐\n{out_msg}"
+
+            return out_msg
+        except Exception as e:
+            out_msg = f"⚠️ **Error checking website access states**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            return out_msg
+
+    #endregion
+
     #region Services
 
     def get_all_services_allowed_to_restart(self, is_private: bool) -> str:
@@ -801,7 +898,7 @@ class LinuxMonitor:
         logging.info(msg=out_msg)
         return out_msg
 
-    def restart_service(self, is_private: bool, service_name: str) -> str:
+    async def restart_service(self, is_private: bool, service_name: str) -> str:
         """
         Restart a specific service.
 
@@ -810,42 +907,47 @@ class LinuxMonitor:
 
         :return: A string containing the result message.
         """
-        if service_name not in self.config['services'].keys():
-            out_msg = f"❌ **Service {service_name} not found**."
-            logging.error(msg=out_msg)
-            return out_msg
+        try:
+            if service_name not in self.config['services'].keys():
+                out_msg = f"❌ **Service {service_name} not found**."
+                logging.error(msg=out_msg)
+                return out_msg
 
-        service = self.config['services'][service_name]
-        if not is_private and is_private != service['is_private']:
-            out_msg = f"❌ **Service {service_name} not authorized to restart in public**."
-            logging.error(msg=out_msg)
-            return out_msg
+            service = self.config['services'][service_name]
+            if not is_private and is_private != service['is_private']:
+                out_msg = f"❌ **Service {service_name} not authorized to restart in public**."
+                logging.error(msg=out_msg)
+                return out_msg
 
-        display_name: str = service.get('display_name', service_name)
-        if 'restart_command' not in service:
-            out_msg = f"❌ **Restart command not found for {display_name}**."
-            logging.error(msg=out_msg)
-            return out_msg
+            display_name: str = service.get('display_name', service_name)
+            if 'restart_command' not in service:
+                out_msg = f"❌ **Restart command not found for {display_name}**."
+                logging.error(msg=out_msg)
+                return out_msg
 
-        timeout_in_sec: int = service.get('timeout_in_sec', 90)
+            timeout_in_sec: int = service.get('timeout_in_sec', 90)
 
-        service_call: List[str] = service['restart_command']
-        out_msg: str = ""
+            service_call: List[str] = service['restart_command']
+            out_msg: str = ""
 
-        logging.info(f"Trying to restart {display_name} (command: {service_call}) in less than {timeout_in_sec}sec...")
+            logging.info(f"Trying to restart {display_name} (command: {service_call}) in less than {timeout_in_sec}sec...")
 
-        start_time: float = time.time()
-        res, out_msg = self.execute_and_verify(command=service_call, display_name=f"restart {display_name}", timeout_in_sec=timeout_in_sec, display_only_if_critical=False)
-        end_time: float = time.time()
+            start_time: float = time.time()
+            res, out_msg = await self.execute_and_verify(command=service_call, display_name=f"restart {display_name}", timeout_in_sec=timeout_in_sec, display_only_if_critical=False)
+            end_time: float = time.time()
 
-        if res == True:
-            readable_duration: str = "{:.2f}".format(end_time - start_time)
-            out_msg = f"✅ **{display_name} restarted with success** in {readable_duration}sec."
-            logging.info(msg=out_msg)
+            if res == True:
+                readable_duration: str = "{:.2f}".format(end_time - start_time)
+                out_msg = f"✅ **{display_name} restarted with success** in {readable_duration}sec."
+                logging.info(msg=out_msg)
 
-        return out_msg
+            return out_msg
+        except Exception as e:
+            out_msg = f"⚠️ **Error restarting service {service_name}**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            return out_msg
 
-    def restart_all_services(self, is_private: bool) -> str:
+    async def restart_all_services(self, is_private: bool) -> str:
         """
         Restart all services allowed to restart which are configured in the JSON configuration file.
 
@@ -853,21 +955,26 @@ class LinuxMonitor:
 
         :return: A string containing the result message.
         """
-        out_msg: str = ""
-        for service_name in self.config["services"].keys():
-            if is_private or self.config["services"][service_name]['is_private'] == is_private:
-                res: str = self.restart_service(is_private=is_private, service_name=service_name)
-                if res != "":
-                    if out_msg:
-                        out_msg += "\n"
-                    out_msg += f"- {res}"
+        try:
+            out_msg: str = ""
+            for service_name in self.config["services"].keys():
+                if is_private or self.config["services"][service_name]['is_private'] == is_private:
+                    res: str = await self.restart_service(is_private=is_private, service_name=service_name)
+                    if res != "":
+                        if out_msg:
+                            out_msg += "\n"
+                        out_msg += f"- {res}"
 
-        if out_msg:
-            out_msg = f"# 📱 Restart services 📱\n{out_msg}"
+            if out_msg:
+                out_msg = f"# 📱 Restart services 📱\n{out_msg}"
 
-        return out_msg
+            return out_msg
+        except Exception as e:
+            out_msg = f"⚠️ **Error restarting services**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            return out_msg
 
-    def _get_service_status(self, is_private: bool, service_name: str) -> Tuple[Optional[bool], str]:
+    async def _get_service_status(self, is_private: bool, service_name: str) -> Tuple[Optional[bool], str]:
         """
         Get the status of a specific service.
 
@@ -876,25 +983,30 @@ class LinuxMonitor:
 
         :return: A tuple containing the status of the service (True for active, False for inactive, None for error) and a string containing the result message.
         """
-        if service_name not in self.config["services"].keys():
-            logging.error(msg=f"Service {service_name} not found")
-            return None, ""
+        try:
+            if service_name not in self.config["services"].keys():
+                logging.error(msg=f"Service {service_name} not found")
+                return None, ""
 
-        service = self.config["services"][service_name]
-        display_name = service.get('display_name', service_name)
-        timeout_in_sec = service.get('timeout_in_sec', 30)
+            service = self.config["services"][service_name]
+            display_name = service.get('display_name', service_name)
+            timeout_in_sec = service.get('timeout_in_sec', 30)
 
-        if 'status_command' not in service:
-            logging.error(msg=f"Status command (status_command) not found for service {service_name}")
-            return None, ""
+            if 'status_command' not in service:
+                logging.error(msg=f"Status command (status_command) not found for service {service_name}")
+                return None, ""
 
-        status_command = service['status_command']
-        check_also_stdout_not_containing = service.get('check_also_stdout_not_containing', None)
+            status_command = service['status_command']
+            check_also_stdout_not_containing = service.get('check_also_stdout_not_containing', None)
 
-        res, out_msg = self.execute_and_verify(command=status_command, display_name=f"état de {display_name}", timeout_in_sec=timeout_in_sec, display_only_if_critical=False, check_also_stdout_not_containing=check_also_stdout_not_containing)
-        return res, out_msg
+            res, out_msg = await self.execute_and_verify(command=status_command, display_name=f"état de {display_name}", timeout_in_sec=timeout_in_sec, display_only_if_critical=False, check_also_stdout_not_containing=check_also_stdout_not_containing)
+            return res, out_msg
+        except Exception as e:
+            out_msg = f"⚠️ **Error checking status of service {service_name}**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            return None, out_msg
 
-    def check_all_services_status(self, is_private: bool) -> str:
+    async def check_all_services_status(self, is_private: bool) -> str:
         """
         Check the status of all services configured in the JSON configuration file.
 
@@ -923,7 +1035,7 @@ class LinuxMonitor:
 
             for service_name in self.config["services"].keys():
                 if is_private or self.config["services"][service_name]['is_private'] == is_private:
-                    status, status_msg = self._get_service_status(is_private=is_private, service_name=service_name)
+                    status, status_msg = await self._get_service_status(is_private=is_private, service_name=service_name)
                     service_status: str = status_to_string(res=status)
                     service_icon: str = status_to_icon(res=status)
                     if out_msg != "":
@@ -937,7 +1049,7 @@ class LinuxMonitor:
 
         return out_msg
 
-    def check_all_services_status_and_restart_if_down(self, is_private: bool) -> str:
+    async def check_all_services_status_and_restart_if_down(self, is_private: bool) -> str:
         """
         Check the status of all services configured in the JSON configuration file and restart them if they are inactive.
 
@@ -949,7 +1061,7 @@ class LinuxMonitor:
         try:
             for service_name in self.config["services"].keys():
                 if is_private or self.config["services"][service_name]['is_private'] == is_private:
-                    status, status_msg = self._get_service_status(is_private=is_private, service_name=service_name)
+                    status, status_msg = await self._get_service_status(is_private=is_private, service_name=service_name)
                     if status is False:
                         out_msg: str = f"❌ **{self.config['services'][service_name]['display_name']} inactive**. Restarting the service is necessary."
                         logging.warning(msg=out_msg)
@@ -957,7 +1069,7 @@ class LinuxMonitor:
                             out_msg += f"\n{status_msg}"
 
                         out_msg_full += out_msg + "\n"
-                        out_msg_full += self.restart_service(is_private=is_private, service_name=service_name) + "\n"
+                        out_msg_full += await self.restart_service(is_private=is_private, service_name=service_name) + "\n"
                     elif status is None:
                         out_msg: str = f"⚠️ **Error checking status of {self.config['services'][service_name]['display_name']}** (not restarting it)."
                         logging.error(msg=out_msg)
@@ -1371,7 +1483,7 @@ class LinuxMonitor:
 
         return res, out_msg
 
-    def check_all_ports(self, is_private: bool, display_only_if_critical: bool=False, restart_if_down: bool=False) -> str:
+    async def check_all_ports(self, is_private: bool, display_only_if_critical: bool=False, restart_if_down: bool=False) -> str:
         """
         Check all ports configured in the JSON configuration file (and restart the service if the port is down and service_name_to_restart added in config file).
 
@@ -1405,7 +1517,7 @@ class LinuxMonitor:
                         if out_msg != "":
                             out_msg += "\n"
 
-                        restart_res: str = self.restart_service(is_private=is_private, service_name=service_name_to_restart)
+                        restart_res: str = await self.restart_service(is_private=is_private, service_name=service_name_to_restart)
                         out_msg += f" - {restart_res}"
 
             if out_msg != "":
@@ -1427,64 +1539,69 @@ class LinuxMonitor:
 
         :return: A string containing the result message.
         """
-        processes = []
-        for process in psutil.process_iter(['pid', 'name', 'username', 'cpu_percent', 'memory_info', 'create_time', 'cmdline']):
-            try:
-                create_time = datetime.fromtimestamp(process.info['create_time']).strftime("%Y-%m-%d %H:%M:%S")
+        try:
+            processes = []
+            for process in psutil.process_iter(['pid', 'name', 'username', 'cpu_percent', 'memory_info', 'create_time', 'cmdline']):
+                try:
+                    create_time = datetime.fromtimestamp(process.info['create_time']).strftime("%Y-%m-%d %H:%M:%S")
 
-                cmdline = ' '.join(process.info['cmdline'])  # Join the command line arguments
-                # Remove extra spaces
-                cmdline = re.sub(r'\s+', ' ', cmdline).strip()
-                if len(cmdline) > 60:
-                    cmdline = cmdline[:60] + '...'  # Truncate and add ellipsis
+                    cmdline = ' '.join(process.info['cmdline'])  # Join the command line arguments
+                    # Remove extra spaces
+                    cmdline = re.sub(r'\s+', ' ', cmdline).strip()
+                    if len(cmdline) > 60:
+                        cmdline = cmdline[:60] + '...'  # Truncate and add ellipsis
 
-                processes.append({ # type: ignore
-                    'pid': process.info['pid'],
-                    'name': process.info['name'],
-                    'username': process.info['username'],
-                    'cpu_percent': process.info['cpu_percent'],
-                    'memory': process.info['memory_info'].rss,  # Resident Set Size (RSS) memory
-                    'create_time': create_time,
-                    'cmdline': cmdline
-                })
-            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-                pass
+                    processes.append({ # type: ignore
+                        'pid': process.info['pid'],
+                        'name': process.info['name'],
+                        'username': process.info['username'],
+                        'cpu_percent': process.info['cpu_percent'],
+                        'memory': process.info['memory_info'].rss,  # Resident Set Size (RSS) memory
+                        'create_time': create_time,
+                        'cmdline': cmdline
+                    })
+                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                    pass
 
-        # Sort processes by memory usage, then by CPU usage, both in descending order
-        processes.sort(key=lambda proc: (proc['memory'], proc['cpu_percent'], proc['create_time']), reverse=True) # type: ignore
+            # Sort processes by memory usage, then by CPU usage, both in descending order
+            processes.sort(key=lambda proc: (proc['memory'], proc['cpu_percent'], proc['create_time']), reverse=True) # type: ignore
 
-        full_res: str = ""
-        for proc in processes: # type: ignore
-            if not get_non_consuming_processes and proc['cpu_percent'] == 0 and proc['memory'] == 0:
-                continue
+            full_res: str = ""
+            for proc in processes: # type: ignore
+                if not get_non_consuming_processes and proc['cpu_percent'] == 0 and proc['memory'] == 0:
+                    continue
 
-            res = f"- PID **{proc['pid']}**: {proc['name']} ("
+                res = f"- PID **{proc['pid']}**: {proc['name']} ("
 
-            if proc['cpu_percent'] > 0:
-                res += f"CPU {proc['cpu_percent']}%, "
+                if proc['cpu_percent'] > 0:
+                    res += f"CPU {proc['cpu_percent']}%, "
 
-            if proc['memory'] > 0:
-                res += f"RAM {proc['memory'] // (1024 * 1024)} MB, "
+                if proc['memory'] > 0:
+                    res += f"RAM {proc['memory'] // (1024 * 1024)} MB, "
 
-            res += f"👤 {proc['username']}, "
-            res += f"⏰ {proc['create_time']}"
+                res += f"👤 {proc['username']}, "
+                res += f"⏰ {proc['create_time']}"
 
-            if proc['cmdline'] != "":
-                res += f", 📄 `{proc['cmdline']}`"
+                if proc['cmdline'] != "":
+                    res += f", 📄 `{proc['cmdline']}`"
 
-            res += ")"
+                res += ")"
 
-            if full_res != "":
-                full_res += "\n"
-            full_res += res
+                if full_res != "":
+                    full_res += "\n"
+                full_res += res
 
-        if full_res != "":
-            full_res = f"# 🔄 Processes 🔄\n{full_res}"
+            if full_res != "":
+                full_res = f"# 🔄 Processes 🔄\n{full_res}"
 
-        logging.info(msg=full_res)
-        return full_res
+            logging.info(msg=full_res)
+            return full_res
+        except Exception as e:
+            out_msg = f"⚠️ **Error getting ordered processes**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            return out_msg
 
-    def kill_process(self, pid: int, timeout_in_sec: int = 10) -> str:
+    async def kill_process(self, pid: int, timeout_in_sec: int = 10) -> str:
         """
         Kills a process with the specified PID.
         1. Tries to terminate the process gracefully
@@ -1522,7 +1639,7 @@ class LinuxMonitor:
 
             # Attempt to terminate the process
             terminate_command: List[str] = ['sudo', '/bin/kill', '-TERM', str(pid)]
-            result_terminate, _ = self.execute_and_verify(command=terminate_command, display_name=f"stop process {pid} ({process_name})", timeout_in_sec=timeout_in_sec, display_only_if_critical=False)
+            result_terminate, _ = await self.execute_and_verify(command=terminate_command, display_name=f"stop process {pid} ({process_name})", timeout_in_sec=timeout_in_sec, display_only_if_critical=False)
 
             if result_terminate == True:
                 out_msg = f"✅ **Process {pid} ({process_name}) stopped with success** (nicely)).\n"
@@ -1534,7 +1651,7 @@ class LinuxMonitor:
 
                 # Attempt to kill the process
                 kill_command = ['sudo', '/bin/kill', '-KILL', str(pid)]
-                _, strerror_kill = self.execute_and_verify(command=kill_command, display_name=f"kill process {pid} ({process_name})", timeout_in_sec=timeout_in_sec, display_only_if_critical=False)
+                _, strerror_kill = await self.execute_and_verify(command=kill_command, display_name=f"kill process {pid} ({process_name})", timeout_in_sec=timeout_in_sec, display_only_if_critical=False)
                 out_msg += strerror_kill
 
             if process_cpu_percent > 0:
@@ -1570,42 +1687,47 @@ class LinuxMonitor:
 
         :return: A string containing the result message.
         """
-        interfaces = psutil.net_if_addrs()
-        stats = psutil.net_if_stats()
-        network_usage: str = ""
+        try:
+            interfaces = psutil.net_if_addrs()
+            stats = psutil.net_if_stats()
+            network_usage: str = ""
 
-        # List of interfaces to exclude (e.g., local interface)
-        excluded_interfaces = {"lo"}
+            # List of interfaces to exclude (e.g., local interface)
+            excluded_interfaces = {"lo"}
 
-        for interface in interfaces:
-            if interface in excluded_interfaces or interface not in stats:
-                continue
+            for interface in interfaces:
+                if interface in excluded_interfaces or interface not in stats:
+                    continue
 
-            ip_addresses = []
-            for snic in interfaces[interface]:
-                if snic.family == socket.AF_INET:
-                    ip_addresses.append(snic.address) # type: ignore
+                ip_addresses = []
+                for snic in interfaces[interface]:
+                    if snic.family == socket.AF_INET:
+                        ip_addresses.append(snic.address) # type: ignore
 
-            # Get network stats
-            net_stats = psutil.net_io_counters(pernic=True).get(interface, None)
-            if net_stats is None:
-                continue
+                # Get network stats
+                net_stats = psutil.net_io_counters(pernic=True).get(interface, None)
+                if net_stats is None:
+                    continue
 
-            # Convert bytes to GB for readability
-            receive_bytes: float = net_stats.bytes_recv / (1024 ** 3)
-            transmit_bytes: float = net_stats.bytes_sent / (1024 ** 3)
+                # Convert bytes to GB for readability
+                receive_bytes: float = net_stats.bytes_recv / (1024 ** 3)
+                transmit_bytes: float = net_stats.bytes_sent / (1024 ** 3)
 
-            ip_str: str = ", ".join(ip_addresses) if ip_addresses else "N/A" # type: ignore
+                ip_str: str = ", ".join(ip_addresses) if ip_addresses else "N/A" # type: ignore
 
-            if network_usage != "":
-                network_usage += "\n"
-            network_usage += f"- {interface} ({ip_str}): ⬇️ {receive_bytes:,.2f} GB, ⬆️ {transmit_bytes:,.2f} GB"
+                if network_usage != "":
+                    network_usage += "\n"
+                network_usage += f"- {interface} ({ip_str}): ⬇️ {receive_bytes:,.2f} GB, ⬆️ {transmit_bytes:,.2f} GB"
 
-        if network_usage != "":
-            network_usage = f"# 🌐 Network usage 🌐\n{network_usage}"
+            if network_usage != "":
+                network_usage = f"# 🌐 Network usage 🌐\n{network_usage}"
 
-        logging.info(msg=network_usage)
-        return network_usage
+            logging.info(msg=network_usage)
+            return network_usage
+        except Exception as e:
+            out_msg = f"⚠️ **Error getting network information**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            return out_msg
 
     #endregion
 
@@ -1624,7 +1746,8 @@ class LinuxMonitor:
         if not self.allow_scheduled_tasks_check_for_issues:
             raise Exception("Scheduled tasks are not allowed")
 
-        await asyncio.sleep(delay=10)  # Sleep for 10 sec before lauching the scheduled tasks (to allow the lib to be ready)
+        logging.info(msg=f"Waiting for 45 seconds before starting the execution of {'private' if is_private else 'public'} scheduled tasks to allow the discord bot and linux server to be ready...")
+        await asyncio.sleep(delay=45)  # Sleep for 45 sec before lauching the scheduled tasks (to allow the lib to be ready)
 
         datetime_last_disk_usage_error_displayed: Optional[datetime] = None
         datetime_last_folder_usage_error_displayed: Optional[datetime] = None
@@ -1633,6 +1756,7 @@ class LinuxMonitor:
         datetime_last_swap_usage_error_displayed: Optional[datetime] = None
         datetime_last_cpu_temperature_error_displayed: Optional[datetime] = None
         datetime_last_ping_error_displayed: Optional[datetime] = None
+        datetime_last_websites_error_displayed: Optional[datetime] = None
         datetime_last_certificates_error_displayed: Optional[datetime] = None
         datetime_last_user_logins_error_displayed: Optional[datetime] = None
         datetime_last_port_error_displayed: Optional[datetime] = None
@@ -1649,7 +1773,7 @@ class LinuxMonitor:
             logging.info(msg="Checking services status and all disk usage, CPU, RAM, Swap, CPU temperature and ping of websites periodically...")
             try:
                 # Services status
-                msg: str = self.check_all_services_status_and_restart_if_down(is_private=is_private)
+                msg: str = await self.check_all_services_status_and_restart_if_down(is_private=is_private)
                 if msg != "":
                     logging.warning(msg=msg)
                     if datetime_last_services_error_displayed is None or ((datetime.now() - datetime_last_services_error_displayed).total_seconds() > self.max_duration_seconds_showing_same_error_again_in_scheduled_tasks):
@@ -1733,7 +1857,7 @@ class LinuxMonitor:
                     logging.info(msg="- ✅ Certificates are OK.")
 
                 # Ping
-                msg = self.ping_all_websites(is_private=is_private, display_only_if_critical=True)
+                msg = await self.ping_all_websites(is_private=is_private, display_only_if_critical=True)
                 if msg != "":
                     logging.warning(msg=msg)
                     if datetime_last_ping_error_displayed is None or ((datetime.now() - datetime_last_ping_error_displayed).total_seconds() > self.max_duration_seconds_showing_same_error_again_in_scheduled_tasks):
@@ -1753,8 +1877,29 @@ class LinuxMonitor:
                 else:
                     logging.info(msg="- ✅ Ping of all websites are OK.")
 
+                # Websites availability (GET request)
+                msg = await self.check_all_websites(is_private=is_private, display_only_if_critical=True)
+                if msg != "":
+                    logging.warning(msg=msg)
+                    if datetime_last_websites_error_displayed is None or ((datetime.now() - datetime_last_websites_error_displayed).total_seconds() > self.max_duration_seconds_showing_same_error_again_in_scheduled_tasks):
+                        if out_msg != "":
+                            out_msg += "\n"
+                        out_msg += msg
+                        datetime_last_websites_error_displayed = datetime.now()
+                    else:
+                        logging.warning(msg="Websites critical but already notified less than 12 hours ago, not notifying...")
+                elif datetime_last_websites_error_displayed is not None:
+                    msg="✅ **Websites returned to normal state**"
+                    logging.info(msg=msg)
+                    if out_msg != "":
+                        out_msg += "\n"
+                    out_msg += msg
+                    datetime_last_websites_error_displayed = None
+                else:
+                    logging.info(msg="- ✅ All websites availability (GET requests) are OK.")
+
                 # Ports
-                msg = self.check_all_ports(is_private=is_private, display_only_if_critical=True, restart_if_down=True)
+                msg = await self.check_all_ports(is_private=is_private, display_only_if_critical=True, restart_if_down=True)
                 if msg != "":
                     logging.warning(msg=msg)
                     if datetime_last_port_error_displayed is None or ((datetime.now() - datetime_last_port_error_displayed).total_seconds() > self.max_duration_seconds_showing_same_error_again_in_scheduled_tasks):
@@ -1922,7 +2067,8 @@ class LinuxMonitor:
         if not self.allow_scheduled_task_show_info:
             raise Exception("Scheduled show info tasks are not allowed")
 
-        await asyncio.sleep(delay=10)
+        logging.info(msg=f"Waiting for 45 seconds before starting the execution of {'private' if is_private else 'public'} show info scheduled tasks to allow the discord bot and linux server to be ready...")
+        await asyncio.sleep(delay=45)
 
         if not self.start_scheduled_task_show_info_immediately:
             logging.info(msg=f"Waiting for {self.duration_in_sec_wait_between_each_schedule_task_show_info_execution} seconds before starting the execution of {'private' if is_private else 'public'} show info scheduled tasks...")
@@ -1934,7 +2080,7 @@ class LinuxMonitor:
                 logging.info(msg="-----------------------------------------------")
 
                 # Services status
-                msg: str = self.check_all_services_status_and_restart_if_down(is_private=is_private)
+                msg: str = await self.check_all_services_status_and_restart_if_down(is_private=is_private)
                 if msg != "":
                     if out_msg != "":
                         out_msg += "\n"
@@ -1962,14 +2108,21 @@ class LinuxMonitor:
                     out_msg += msg
 
                 # Ping
-                msg = self.ping_all_websites(is_private=is_private, display_only_if_critical=False)
+                msg = await self.ping_all_websites(is_private=is_private, display_only_if_critical=False)
+                if msg != "":
+                    if out_msg != "":
+                        out_msg += "\n"
+                    out_msg += msg
+
+                # Websites availability (GET request)
+                msg = await self.check_all_websites(is_private=is_private, display_only_if_critical=False)
                 if msg != "":
                     if out_msg != "":
                         out_msg += "\n"
                     out_msg += msg
 
                 # Ports
-                msg = self.check_all_ports(is_private=is_private, display_only_if_critical=False, restart_if_down=False)
+                msg = await self.check_all_ports(is_private=is_private, display_only_if_critical=False, restart_if_down=False)
                 if msg != "":
                     if out_msg != "":
                         out_msg += "\n"

{linuxmonitor-1.1.1 → linuxmonitor-1.2.0}/setup.py

@@ -6,7 +6,7 @@ with io.open(file='README.md', mode='r', encoding='utf-8') as readme_file:
 
 setup(
     name="LinuxMonitor",
-    version="1.1.1",
+    version="1.2.0",
     description="Get information and warning status of Linux server like service, port, ping, ssl certificate, disk/folder/cpu/ram/swap usage, ip connection, ... (Python and shell library, Linux ONLY)",
     long_description=readme,
     long_description_content_type="text/markdown",