sysbot 0.2.2__tar.gz → 0.2.3__tar.gz

{sysbot-0.2.2 → sysbot-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysbot
-Version: 0.2.2
+Version: 0.2.3
 Summary: System test automation library with support for SSH, WinRM, HTTP, databases, and Robot Framework integration
 Home-page: https://github.com/JoReci2/sysbot
 Author: Thibault SCIRE
@@ -33,7 +33,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: robotframework
 Requires-Dist: paramiko
-Requires-Dist: sshtunnel
 Requires-Dist: netmiko
 Requires-Dist: redfish
 Requires-Dist: pywinrm

{sysbot-0.2.2 → sysbot-0.2.3}/setup.py

@@ -26,7 +26,6 @@ setup(
     install_requires=[
         "robotframework",
         "paramiko",
-        "sshtunnel",
         "netmiko",
         "redfish",
         "pywinrm",

{sysbot-0.2.2 → sysbot-0.2.3}/sysbot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.2.3'
+__version_tuple__ = version_tuple = (0, 2, 3)
 
-__commit_id__ = commit_id = 'g98ca5fe32'
+__commit_id__ = commit_id = 'gaa9194bbf'

sysbot-0.2.3/sysbot/modules/container/__init__.py

@@ -0,0 +1,7 @@
+"""
+Container Modules Package
+
+This package provides modules for container platform management, including
+Kubernetes orchestration and Podman container operations, enabling automation
+of containerized workloads and their infrastructure.
+"""

{sysbot-0.2.2 → sysbot-0.2.3}/sysbot/modules/linux/dnf.py

@@ -6,7 +6,6 @@ RHEL/Fedora-based Linux systems, including repository management and package
 operations.
 """
 from sysbot.utils.engine import ComponentBase
-import json
 import configparser
 from io import StringIO
 
@@ -14,7 +13,7 @@ from io import StringIO
 class Dnf(ComponentBase):
     """DNF package manager operations class for RHEL/Fedora-based systems."""
 
-    def repolist(self, alias: str, **kwargs) -> dict:
+    def repolist(self, alias: str, **kwargs) -> list:
         """
         Get list of DNF repositories.
 
@@ -23,10 +22,27 @@ class Dnf(ComponentBase):
             **kwargs: Additional command execution options.
 
         Returns:
-            Dictionary containing repository information in JSON format.
+            List of dictionaries containing repository information,
+            each with 'id' and 'name' keys.
         """
-        output = self.execute_command(alias, "dnf repolist --json", **kwargs)
-        return json.loads(output)
+        output = self.execute_command(alias, "dnf repolist", **kwargs)
+        repos = []
+        # Locate the header line (e.g. "repo id    repo name") and parse
+        # only the lines that follow it, skipping any metadata lines printed
+        # before the table (e.g. "Last metadata expiration check: …").
+        header_found = False
+        for line in output.splitlines():
+            if not header_found:
+                if line.lstrip().lower().startswith("repo id"):
+                    header_found = True
+                continue
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split(None, 1)
+            if parts:
+                repos.append({"id": parts[0], "name": parts[1].strip() if len(parts) > 1 else ""})
+        return repos
 
     def repofile(self, alias: str, file: str, **kwargs) -> dict:
         """

sysbot-0.2.3/sysbot/modules/virtualization/__init__.py

@@ -0,0 +1,7 @@
+"""
+Virtualization Modules Package
+
+This package provides modules for virtualization platform management,
+covering VMware virtualization platforms, libvirt-based virtualization,
+and related virtualization technologies.
+"""

sysbot-0.2.3/sysbot/modules/virtualization/harvester.py

@@ -0,0 +1,381 @@
+"""
+Harvester Module
+
+This module provides methods for interacting with Rancher Harvester HCI (Hyper-Converged Infrastructure)
+via REST API. It supports operations such as virtual machine management, image management,
+volume management, and cluster information retrieval.
+
+Note: This module uses the HTTP connector with API Key or Basic authentication.
+Sessions should be opened with protocol="http" and product="apikey" or "basicauth".
+"""
+
+import json
+from sysbot.utils.engine import ComponentBase
+
+
+class Harvester(ComponentBase):
+    """
+    Harvester module for hyper-converged infrastructure management.
+    
+    This class provides methods to interact with Rancher Harvester systems using REST API
+    via the HTTP connector with API Key or Basic authentication.
+    All methods require an alias to identify the established HTTP session.
+    
+    Example:
+        Basic usage with API key authentication::
+        
+            import sysbot
+            
+            bot = sysbot.Sysbot(['modules.virtualization.harvester'])
+            
+            # Open session with API key
+            bot.open_session(
+                "harvester",
+                "http",
+                "apikey",
+                "harvester.example.com",
+                443,
+                apikey="your-api-key-here"
+            )
+            
+            # Get cluster version
+            version = bot.modules.virtualization.harvester.get_version("harvester")
+            
+            # List virtual machines
+            vms = bot.modules.virtualization.harvester.list_virtual_machines("harvester")
+            
+            # Get specific VM
+            vm = bot.modules.virtualization.harvester.get_virtual_machine("harvester", "my-vm")
+            
+            bot.close_session("harvester")
+    """
+    
+    def _parse_response(self, response):
+        """
+        Parse HTTP response and decode JSON.
+        
+        Args:
+            response: The raw HTTP response bytes.
+            
+        Returns:
+            Parsed JSON object (dict or list).
+        """
+        return json.loads(response.decode())
+
+    def get_version(self, alias: str, **kwargs) -> dict:
+        """
+        Get Harvester version information.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+
+        Returns:
+            dict: Version information.
+        """
+        response = self.execute_command(alias, "/v1/harvesterhci.io.settings/server-version", options={"method": "GET"}, **kwargs)
+        return self._parse_response(response)
+
+    def list_virtual_machines(self, alias: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        List all virtual machines in a namespace.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: List of virtual machines.
+        """
+        response = self.execute_command(
+            alias,
+            f"/apis/kubevirt.io/v1/namespaces/{namespace}/virtualmachines",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def get_virtual_machine(self, alias: str, name: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        Get details of a specific virtual machine.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            name (str): Virtual machine name.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: Virtual machine details.
+        """
+        response = self.execute_command(
+            alias,
+            f"/apis/kubevirt.io/v1/namespaces/{namespace}/virtualmachines/{name}",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def list_vm_instances(self, alias: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        List all virtual machine instances in a namespace.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: List of virtual machine instances.
+        """
+        response = self.execute_command(
+            alias,
+            f"/apis/kubevirt.io/v1/namespaces/{namespace}/virtualmachineinstances",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def get_vm_instance(self, alias: str, name: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        Get details of a specific virtual machine instance.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            name (str): Virtual machine instance name.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: Virtual machine instance details.
+        """
+        response = self.execute_command(
+            alias,
+            f"/apis/kubevirt.io/v1/namespaces/{namespace}/virtualmachineinstances/{name}",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def list_images(self, alias: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        List all VM images in a namespace.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: List of VM images.
+        """
+        response = self.execute_command(
+            alias,
+            f"/apis/harvesterhci.io/v1beta1/namespaces/{namespace}/virtualmachineimages",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def get_image(self, alias: str, name: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        Get details of a specific VM image.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            name (str): Image name.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: Image details.
+        """
+        response = self.execute_command(
+            alias,
+            f"/apis/harvesterhci.io/v1beta1/namespaces/{namespace}/virtualmachineimages/{name}",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def list_volume_claims(self, alias: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        List all persistent volume claims in a namespace.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: List of persistent volume claims.
+        """
+        response = self.execute_command(
+            alias,
+            f"/api/v1/namespaces/{namespace}/persistentvolumeclaims",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def get_volume_claim(self, alias: str, name: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        Get details of a specific persistent volume claim.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            name (str): Volume claim name.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: Volume claim details.
+        """
+        response = self.execute_command(
+            alias,
+            f"/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def list_networks(self, alias: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        List all networks in a namespace.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: List of networks.
+        """
+        response = self.execute_command(
+            alias,
+            f"/apis/k8s.cni.cncf.io/v1/namespaces/{namespace}/network-attachment-definitions",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def get_network(self, alias: str, name: str, namespace: str = "default", **kwargs) -> dict:
+        """
+        Get details of a specific network.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            name (str): Network name.
+            namespace (str): Kubernetes namespace (default: "default").
+
+        Returns:
+            dict: Network details.
+        """
+        response = self.execute_command(
+            alias,
+            f"/apis/k8s.cni.cncf.io/v1/namespaces/{namespace}/network-attachment-definitions/{name}",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def list_nodes(self, alias: str, **kwargs) -> dict:
+        """
+        List all cluster nodes.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+
+        Returns:
+            dict: List of cluster nodes.
+        """
+        response = self.execute_command(
+            alias,
+            "/api/v1/nodes",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def get_node(self, alias: str, name: str, **kwargs) -> dict:
+        """
+        Get details of a specific cluster node.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            name (str): Node name.
+
+        Returns:
+            dict: Node details.
+        """
+        response = self.execute_command(
+            alias,
+            f"/api/v1/nodes/{name}",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def list_namespaces(self, alias: str, **kwargs) -> dict:
+        """
+        List all namespaces in the cluster.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+
+        Returns:
+            dict: List of namespaces.
+        """
+        response = self.execute_command(
+            alias,
+            "/api/v1/namespaces",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def get_cluster_info(self, alias: str, **kwargs) -> dict:
+        """
+        Get cluster information.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+
+        Returns:
+            dict: Cluster information.
+        """
+        response = self.execute_command(
+            alias,
+            "/api/v1",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def list_settings(self, alias: str, **kwargs) -> dict:
+        """
+        List all Harvester settings.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+
+        Returns:
+            dict: List of Harvester settings.
+        """
+        response = self.execute_command(
+            alias,
+            "/v1/harvesterhci.io.settings",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)
+
+    def get_setting(self, alias: str, name: str, **kwargs) -> dict:
+        """
+        Get a specific Harvester setting.
+
+        Args:
+            alias (str): The session alias for the Harvester connection.
+            name (str): Setting name.
+
+        Returns:
+            dict: Setting details.
+        """
+        response = self.execute_command(
+            alias,
+            f"/v1/harvesterhci.io.settings/{name}",
+            options={"method": "GET"},
+            **kwargs
+        )
+        return self._parse_response(response)

{sysbot-0.2.2 → sysbot-0.2.3}/sysbot/utils/engine.py

@@ -26,13 +26,118 @@ import base64
 import os
 import json
 import importlib
-from sshtunnel import SSHTunnelForwarder
+import select
+import socket
+import threading
+import paramiko
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Dict, Optional, Union, List
 from cryptography.fernet import Fernet
 
 
+class SSHTunnel:
+    """
+    A lightweight SSH tunnel implementation using paramiko, replacing the
+    unmaintained sshtunnel library which is incompatible with paramiko >= 3.x
+    (paramiko removed DSSKey in version 3.0).
+    """
+
+    def __init__(
+        self,
+        ssh_address_or_host,
+        remote_bind_address,
+        ssh_username=None,
+        ssh_password=None,
+    ):
+        self._ssh_host, self._ssh_port = ssh_address_or_host
+        self._remote_host, self._remote_port = remote_bind_address
+        self._ssh_username = ssh_username
+        self._ssh_password = ssh_password
+        self._transport = None
+        self._server_socket = None
+        self._local_bind_port = None
+        self._stop_event = threading.Event()
+        self._accept_thread = None
+
+    @property
+    def local_bind_port(self):
+        return self._local_bind_port
+
+    def start(self):
+        self._transport = paramiko.Transport((self._ssh_host, self._ssh_port))
+        self._transport.connect(
+            username=self._ssh_username, password=self._ssh_password
+        )
+
+        self._server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._server_socket.bind(("127.0.0.1", 0))
+        self._local_bind_port = self._server_socket.getsockname()[1]
+        self._server_socket.listen(5)
+
+        self._accept_thread = threading.Thread(
+            target=self._accept_loop, daemon=True
+        )
+        self._accept_thread.start()
+
+    def _accept_loop(self):
+        while not self._stop_event.is_set():
+            self._server_socket.settimeout(1.0)
+            try:
+                client_sock, addr = self._server_socket.accept()
+            except socket.timeout:
+                continue
+            except OSError:
+                break
+            try:
+                channel = self._transport.open_channel(
+                    "direct-tcpip",
+                    (self._remote_host, self._remote_port),
+                    addr,
+                )
+            except paramiko.SSHException:
+                client_sock.close()
+                continue
+            t = threading.Thread(
+                target=self._forward_data,
+                args=(client_sock, channel),
+                daemon=True,
+            )
+            t.start()
+
+    def _forward_data(self, client_sock, channel):
+        try:
+            while not self._stop_event.is_set():
+                r, _, _ = select.select([client_sock, channel], [], [], 1.0)
+                if client_sock in r:
+                    data = client_sock.recv(4096)
+                    if not data:
+                        break
+                    channel.sendall(data)
+                if channel in r:
+                    data = channel.recv(4096)
+                    if not data:
+                        break
+                    client_sock.sendall(data)
+        finally:
+            client_sock.close()
+            channel.close()
+
+    def stop(self):
+        self._stop_event.set()
+        if self._server_socket:
+            try:
+                self._server_socket.close()
+            except OSError:
+                pass
+        if self._transport:
+            try:
+                self._transport.close()
+            except paramiko.SSHException:
+                pass
+
+
 class ConnectorInterface(ABC):
     def __init__(self):
         self._cache = None
@@ -205,7 +310,7 @@ class TunnelingManager:
                     int(tunnel_config[index + 1]["port"]),
                 )
             )
-            tunnel = SSHTunnelForwarder(
+            tunnel = SSHTunnel(
                 ssh_address_or_host=ssh_address_or_host,
                 remote_bind_address=remote_bind_address,
                 ssh_username=config["username"],

{sysbot-0.2.2 → sysbot-0.2.3}/sysbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysbot
-Version: 0.2.2
+Version: 0.2.3
 Summary: System test automation library with support for SSH, WinRM, HTTP, databases, and Robot Framework integration
 Home-page: https://github.com/JoReci2/sysbot
 Author: Thibault SCIRE
@@ -33,7 +33,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: robotframework
 Requires-Dist: paramiko
-Requires-Dist: sshtunnel
 Requires-Dist: netmiko
 Requires-Dist: redfish
 Requires-Dist: pywinrm

{sysbot-0.2.2 → sysbot-0.2.3}/sysbot.egg-info/SOURCES.txt

@@ -26,15 +26,15 @@ sysbot/modules/__init__.py
 sysbot/modules/bmc/__init__.py
 sysbot/modules/bmc/idrac.py
 sysbot/modules/bmc/ilo.py
+sysbot/modules/container/__init__.py
+sysbot/modules/container/kubernetes.py
+sysbot/modules/container/podman.py
 sysbot/modules/linux/__init__.py
 sysbot/modules/linux/dnf.py
 sysbot/modules/linux/file.py
 sysbot/modules/linux/firewalld.py
 sysbot/modules/linux/ip.py
 sysbot/modules/linux/iptables.py
-sysbot/modules/linux/kubernetes.py
-sysbot/modules/linux/libvirt.py
-sysbot/modules/linux/podman.py
 sysbot/modules/linux/process.py
 sysbot/modules/linux/rpm.py
 sysbot/modules/linux/selinux.py
@@ -46,10 +46,13 @@ sysbot/modules/monitoring/grafana.py
 sysbot/modules/network/__init__.py
 sysbot/modules/network/cisco/__init__.py
 sysbot/modules/network/cisco/catalyst.py
-sysbot/modules/vmware/__init__.py
-sysbot/modules/vmware/nsx.py
-sysbot/modules/vmware/sddcmanager.py
-sysbot/modules/vmware/vsphere.py
+sysbot/modules/virtualization/__init__.py
+sysbot/modules/virtualization/harvester.py
+sysbot/modules/virtualization/libvirt.py
+sysbot/modules/virtualization/vmware/__init__.py
+sysbot/modules/virtualization/vmware/nsx.py
+sysbot/modules/virtualization/vmware/sddcmanager.py
+sysbot/modules/virtualization/vmware/vsphere.py
 sysbot/modules/windows/__init__.py
 sysbot/modules/windows/adcs.py
 sysbot/modules/windows/adds.py

{sysbot-0.2.2 → sysbot-0.2.3}/sysbot.egg-info/requires.txt

@@ -1,6 +1,5 @@
 robotframework
 paramiko
-sshtunnel
 netmiko
 redfish
 pywinrm