golem-vm-provider 0.1.13__py3-none-any.whl → 0.1.16__py3-none-any.whl

{golem_vm_provider-0.1.13.dist-info → golem_vm_provider-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.13
+Version: 0.1.16
 Summary: VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network
 Keywords: golem,vm,provider,cloud,decentralized
 Author: Phillip Jensen

{golem_vm_provider-0.1.13.dist-info → golem_vm_provider-0.1.16.dist-info}/RECORD

@@ -2,11 +2,11 @@ provider/__init__.py,sha256=HO1fkPpZqPO3z8O8-eVIyx8xXSMIVuTR_b1YF0RtXOg,45
 provider/api/__init__.py,sha256=ssX1ugDqEPt8Fn04IymgmG-Ev8PiXLsCSaiZVvHQnec,344
 provider/api/models.py,sha256=JOzoNf1oE5N97UqTN5xuIrTkqn2tCHqPDaIzGA3jUyo,3513
 provider/api/routes.py,sha256=P27RQvNqFWn6PacRwr1PaVz-yv5KAWsp9KeORejkXSI,6452
-provider/config.py,sha256=41FhWAzPJrbyu1VJC4YOMLl79RzYmzFpOjEuS2MZSm4,9128
+provider/config.py,sha256=tF51xZqu-7x_cmHS3lQaAZorjk7DTZOZuOlU-O8Gk9k,11204
 provider/discovery/__init__.py,sha256=VR3NRoQtZRH5Vs8FG7jnGLR7p7wn7XeZdLaBb3t8e1g,123
 provider/discovery/advertiser.py,sha256=yv7RbRf1K43qOLAEa2Olj9hhN8etl2qsBuoHok0xoVs,6784
 provider/discovery/resource_tracker.py,sha256=8dYhJxoe_jLRwisHoA0jr575YhUKmLIqSXfW88KshcQ,6000
-provider/main.py,sha256=_kZTDqOlkI7cuFCKhB_WvHN3vlxPpCWqEausdUMzYpM,10232
+provider/main.py,sha256=nVuMxq6npioif4-bFXGjQWJCKdy6O5ZbtX3zxhCM3zI,9206
 provider/network/port_verifier.py,sha256=AUtBGuZdfq9Jt4BRDuYesh5YEmwneEzYUgIw-uajZhA,12977
 provider/security/ethereum.py,sha256=SDRDbcjynbVy44kNnxlDcYLL0BZ3Qnc0DvmneQ-WKLE,1383
 provider/utils/ascii_art.py,sha256=ykBFsztk57GIiz1NJ-EII5UvN74iECqQL4h9VmiW6Z8,3161
@@ -14,13 +14,13 @@ provider/utils/logging.py,sha256=C_elr0sJROHKQgErYpHJQvfujgh0k4Zf2gg8ZKfrmVk,259
 provider/utils/port_display.py,sha256=5d_604Eo-82dqx_yV2ZScq7bKQ8IsXacc-yXC_KAz3A,11031
 provider/utils/retry.py,sha256=ekP2ucaSJNN-lBcrIvyHa4QYPKNITMl1a5V1X6BBvsw,1560
 provider/vm/__init__.py,sha256=JGs50tUmzOR1rQ_w4fMY_3XWylmiA1G7KKWZkVw51mY,501
-provider/vm/cloud_init.py,sha256=o2CWLjl1ZN9fSEFHAWO-glh7BW-DxAMSe0MbqhzKNTg,1709
+provider/vm/cloud_init.py,sha256=lgOlpiWTtdZi6jbYceA4XERITAfJZjWi12XI3aAIIF8,3267
 provider/vm/models.py,sha256=zkfvP5Z50SPDNajwZTt9NTDIMRQIsZLvSOsuirHEcJM,6256
-provider/vm/multipass.py,sha256=RLUqCeoYz4PG8RL7dBu_TzjNEAmgIz9NonBtSuYc4kw,16431
+provider/vm/multipass.py,sha256=FOcsfcJ-NrgBg_fvq_CKOKsQ0xOmk7Z34KXi3ag_Vl8,16603
 provider/vm/name_mapper.py,sha256=MrshNeJ4Dw-WBsyiIVcn9N5xyOxaBKX4Yqhyh_m5IFg,4103
 provider/vm/port_manager.py,sha256=d03uwU76vx6LgADMN8ffBT9t400XQ3vtYlXr6cLIFN0,9831
 provider/vm/proxy_manager.py,sha256=cu0FPPbeCc3CR6NRE_CnLjiRg7xVdSFUylVUOL1g1sI,10154
-golem_vm_provider-0.1.13.dist-info/METADATA,sha256=zaGnsTHOW6OEZAOOpl-a3gchR9ESFbDNNfOR35JJUSQ,10594
-golem_vm_provider-0.1.13.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-golem_vm_provider-0.1.13.dist-info/entry_points.txt,sha256=E4rCWo_Do_2zCG_GewNuftfVlHF_8b_OvioZre0dfeA,54
-golem_vm_provider-0.1.13.dist-info/RECORD,,
+golem_vm_provider-0.1.16.dist-info/METADATA,sha256=8pEYP425VQlfm1bpPWB5RiQ-1eaftoMAvox-T7VeW_w,10594
+golem_vm_provider-0.1.16.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+golem_vm_provider-0.1.16.dist-info/entry_points.txt,sha256=E4rCWo_Do_2zCG_GewNuftfVlHF_8b_OvioZre0dfeA,54
+golem_vm_provider-0.1.16.dist-info/RECORD,,

provider/config.py

@@ -56,25 +56,65 @@ class Settings(BaseSettings):
     DEFAULT_VM_IMAGE: str = "ubuntu:24.04"
     VM_DATA_DIR: str = ""
     SSH_KEY_DIR: str = ""
+    CLOUD_INIT_DIR: str = ""
+
+    @validator("CLOUD_INIT_DIR", pre=True)
+    def resolve_cloud_init_dir(cls, v: str) -> str:
+        """Resolve and create cloud-init directory path."""
+        if not v:
+            path = Path.home() / ".golem" / "provider" / "cloud-init"
+        else:
+            path = Path(v)
+            if not path.is_absolute():
+                path = Path.home() / path
+        
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+            path.chmod(0o755)  # Readable and executable by owner and others, writable by owner
+            logger.debug(f"Created cloud-init directory at {path}")
+        except Exception as e:
+            logger.error(f"Failed to create cloud-init directory at {path}: {e}")
+            raise ValueError(f"Failed to create cloud-init directory: {e}")
+            
+        return str(path)
 
     @validator("VM_DATA_DIR", pre=True)
     def resolve_vm_data_dir(cls, v: str) -> str:
-        """Resolve VM data directory path."""
+        """Resolve and create VM data directory path."""
         if not v:
-            return str(Path.home() / ".golem" / "provider" / "vms")
-        path = Path(v)
-        if not path.is_absolute():
-            path = Path.home() / path
+            path = Path.home() / ".golem" / "provider" / "vms"
+        else:
+            path = Path(v)
+            if not path.is_absolute():
+                path = Path.home() / path
+        
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+            logger.debug(f"Created VM data directory at {path}")
+        except Exception as e:
+            logger.error(f"Failed to create VM data directory at {path}: {e}")
+            raise ValueError(f"Failed to create VM data directory: {e}")
+            
         return str(path)
 
     @validator("SSH_KEY_DIR", pre=True)
     def resolve_ssh_key_dir(cls, v: str) -> str:
-        """Resolve SSH key directory path."""
+        """Resolve and create SSH key directory path with secure permissions."""
         if not v:
-            return str(Path.home() / ".golem" / "provider" / "ssh")
-        path = Path(v)
-        if not path.is_absolute():
-            path = Path.home() / path
+            path = Path.home() / ".golem" / "provider" / "ssh"
+        else:
+            path = Path(v)
+            if not path.is_absolute():
+                path = Path.home() / path
+        
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+            path.chmod(0o700)  # Secure permissions for SSH keys
+            logger.debug(f"Created SSH key directory at {path} with secure permissions")
+        except Exception as e:
+            logger.error(f"Failed to create SSH key directory at {path}: {e}")
+            raise ValueError(f"Failed to create SSH key directory: {e}")
+            
         return str(path)
 
     # Resource Settings
@@ -108,20 +148,22 @@ class Settings(BaseSettings):
 
         # If path provided via environment variable, ONLY validate that path
         if v:
-            logger.debug(f"Using provided multipass path: {v}")
+            logger.info(f"Checking multipass binary at: {v}")
             if not validate_path(v):
-                logger.error(f"Provided path {v} is invalid or not executable")
-                raise ValueError(f"Invalid multipass binary path: {v}")
+                msg = f"Invalid multipass binary path: {v} (not found or not executable)"
+                logger.error(msg)
+                raise ValueError(msg)
+            logger.info(f"✓ Found valid multipass binary at: {v}")
             return v
 
-        logger.debug("No multipass path provided, attempting auto-detection")
+        logger.info("No multipass path provided, attempting auto-detection...")
         system = platform.system().lower()
-        logger.debug(f"Detected OS: {system}")
+        logger.info(f"Detected OS: {system}")
         binary_name = "multipass.exe" if system == "windows" else "multipass"
         
         # Try to find multipass based on OS
         if system == "linux":
-            logger.debug("Checking for snap installation on Linux")
+            logger.info("Checking for snap installation...")
             # First try to find snap and check if multipass is installed
             try:
                 # Check if snap exists
@@ -132,7 +174,7 @@ class Settings(BaseSettings):
                     check=True
                 )
                 if snap_result.returncode == 0:
-                    logger.debug("Found snap, checking for multipass installation")
+                    logger.info("✓ Found snap, checking for multipass installation...")
                     # Check if multipass is installed via snap
                     try:
                         snap_list = subprocess.run(
@@ -144,13 +186,13 @@ class Settings(BaseSettings):
                         if snap_list.returncode == 0:
                             snap_path = "/snap/bin/multipass"
                             if validate_path(snap_path):
-                                logger.debug(f"Found multipass via snap at {snap_path}")
+                                logger.info(f"✓ Found multipass via snap at {snap_path}")
                                 return snap_path
                     except subprocess.CalledProcessError:
-                        logger.debug("Multipass not installed via snap")
+                        logger.info("✗ Multipass not installed via snap")
                         pass
             except subprocess.CalledProcessError:
-                logger.debug("Snap not found")
+                logger.info("✗ Snap not found")
                 pass
                 
             # Common Linux paths if snap installation not found
@@ -159,7 +201,7 @@ class Settings(BaseSettings):
                 "/usr/bin",
                 "/snap/bin"
             ]
-            logger.debug(f"Checking common Linux paths: {search_paths}")
+            logger.info(f"Checking common Linux paths: {', '.join(search_paths)}")
                 
         elif system == "darwin":  # macOS
             search_paths = [
@@ -167,7 +209,7 @@ class Settings(BaseSettings):
                 "/usr/local/bin",       # Intel Mac
                 "/opt/local/bin"        # MacPorts
             ]
-            logger.debug(f"Checking macOS paths: {search_paths}")
+            logger.info(f"Checking macOS paths: {', '.join(search_paths)}")
                 
         elif system == "windows":
             search_paths = [
@@ -175,21 +217,18 @@ class Settings(BaseSettings):
                 os.path.expandvars(r"%ProgramFiles(x86)%\Multipass"),
                 os.path.expandvars(r"%LocalAppData%\Multipass")
             ]
-            logger.debug(f"Checking Windows paths: {search_paths}")
+            logger.info(f"Checking Windows paths: {', '.join(search_paths)}")
                 
         else:
             search_paths = ["/usr/local/bin", "/usr/bin"]
-            logger.debug(f"Checking default paths: {search_paths}")
+            logger.info(f"Checking default paths: {', '.join(search_paths)}")
 
         # Search for multipass binary in OS-specific paths
         for directory in search_paths:
             path = os.path.join(directory, binary_name)
-            logger.debug(f"Checking path: {path}")
             if validate_path(path):
-                logger.debug(f"Found valid multipass binary at: {path}")
+                logger.info(f"✓ Found valid multipass binary at: {path}")
                 return path
-            else:
-                logger.debug(f"No valid multipass binary at: {path}")
 
         # OS-specific installation instructions
         if system == "linux":
@@ -224,12 +263,21 @@ class Settings(BaseSettings):
 
     @validator("PROXY_STATE_DIR", pre=True)
     def resolve_proxy_state_dir(cls, v: str) -> str:
-        """Resolve proxy state directory path."""
+        """Resolve and create proxy state directory path."""
         if not v:
-            return str(Path.home() / ".golem" / "provider" / "proxy")
-        path = Path(v)
-        if not path.is_absolute():
-            path = Path.home() / path
+            path = Path.home() / ".golem" / "provider" / "proxy"
+        else:
+            path = Path(v)
+            if not path.is_absolute():
+                path = Path.home() / path
+        
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+            logger.debug(f"Created proxy state directory at {path}")
+        except Exception as e:
+            logger.error(f"Failed to create proxy state directory at {path}: {e}")
+            raise ValueError(f"Failed to create proxy state directory: {e}")
+            
         return str(path)
 
     @validator("PUBLIC_IP", pre=True)

provider/main.py

@@ -163,41 +163,13 @@ __all__ = ["app", "start"]
 
 def check_requirements():
     """Check if all requirements are met."""
-    import os
-    from pathlib import Path
-    
-    # Check if multipass is installed
-    multipass_path = os.environ.get('GOLEM_PROVIDER_MULTIPASS_BINARY_PATH', '/usr/local/bin/multipass')
-    if not Path(multipass_path).exists():
-        logger.error(f"Multipass binary not found at {multipass_path}")
-        return False
-        
-    # Check required directories
-    vm_data_dir = os.environ.get(
-        'GOLEM_PROVIDER_VM_DATA_DIR',
-        str(Path.home() / '.golem' / 'provider' / 'vms')
-    )
-    ssh_key_dir = os.environ.get(
-        'GOLEM_PROVIDER_SSH_KEY_DIR',
-        str(Path.home() / '.golem' / 'provider' / 'ssh')
-    )
-    proxy_state_dir = os.environ.get(
-        'GOLEM_PROVIDER_PROXY_STATE_DIR',
-        str(Path.home() / '.golem' / 'provider' / 'proxy')
-    )
-    
     try:
-        # Create and secure directories
-        for directory in [vm_data_dir, ssh_key_dir, proxy_state_dir]:
-            path = Path(directory)
-            path.mkdir(parents=True, exist_ok=True)
-            if directory == ssh_key_dir:
-                path.chmod(0o700)  # Secure permissions for SSH keys
+        # Import settings to trigger validation
+        from .config import settings
+        return True
     except Exception as e:
-        logger.error(f"Failed to create required directories: {e}")
+        logger.error(f"Requirements check failed: {e}")
         return False
-        
-    return True
 
 async def verify_provider_port(port: int) -> bool:
     """Verify that the provider port is available for binding.

provider/vm/cloud_init.py

@@ -1,14 +1,20 @@
 import yaml
-import tempfile
+import os
+from datetime import datetime
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, Tuple
+
+from ..config import settings
+from ..utils.logging import setup_logger
+
+logger = setup_logger(__name__)
 
 def generate_cloud_init(
     hostname: str,
     ssh_key: str,
     packages: Optional[list[str]] = None,
     runcmd: Optional[list[str]] = None
-) -> str:
+) -> Tuple[str, str]:
     """Generate cloud-init configuration.
     
     Args:
@@ -18,50 +24,75 @@ def generate_cloud_init(
         runcmd: List of commands to run on first boot
     
     Returns:
-        Path to cloud-init configuration file
+        Tuple of (path to cloud-init configuration file, config_id for debugging)
     """
-    config = {
-        "hostname": hostname,
-        "package_update": True,
-        "package_upgrade": True,
-        "ssh_authorized_keys": [ssh_key],
-        "users": [{
-            "name": "root",
-            "ssh_authorized_keys": [ssh_key]
-        }],
-        "write_files": [
-            {
-                "path": "/etc/ssh/sshd_config.d/allow_root.conf",
-                "content": "PermitRootLogin prohibit-password\n",
-                "owner": "root:root",
-                "permissions": "0644"
-            }
-        ],
-        "runcmd": [
-            "systemctl restart ssh"
-        ]
-    }
+    # Generate unique config ID for this cloud-init file
+    config_id = f"{hostname}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+    config_path = Path(settings.CLOUD_INIT_DIR) / f"{config_id}.yaml"
+    
+    logger.info(f"Generating cloud-init configuration {config_id}")
+    try:
+        config = {
+            "hostname": hostname,
+            "package_update": True,
+            "package_upgrade": True,
+            "ssh_authorized_keys": [ssh_key],
+            "users": [{
+                "name": "root",
+                "ssh_authorized_keys": [ssh_key]
+            }],
+            "write_files": [
+                {
+                    "path": "/etc/ssh/sshd_config.d/allow_root.conf",
+                    "content": "PermitRootLogin prohibit-password\n",
+                    "owner": "root:root",
+                    "permissions": "0644"
+                }
+            ],
+            "runcmd": [
+                "systemctl restart ssh"
+            ]
+        }
+
+        if packages:
+            config["packages"] = packages
 
-    if packages:
-        config["packages"] = packages
+        if runcmd:
+            config["runcmd"].extend(runcmd)
 
-    if runcmd:
-        config["runcmd"].extend(runcmd)
+        # Validate YAML before writing
+        yaml_content = yaml.safe_dump(config)
+        yaml.safe_load(yaml_content)  # Validate by parsing
 
-    # Create temporary file
-    temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False)
-    yaml.safe_dump(config, temp_file)
-    temp_file.close()
+        # Write to file in our managed directory
+        with open(config_path, 'w') as f:
+            f.write(yaml_content)
+        
+        # Set proper permissions
+        config_path.chmod(0o644)  # World readable but only owner writable
+        
+        logger.debug(f"Cloud-init configuration written to {config_path}")
+        logger.debug(f"Cloud-init configuration content:\n{yaml_content}")
+        
+        return str(config_path), config_id
 
-    return temp_file.name
+    except Exception as e:
+        error_msg = f"Failed to generate cloud-init configuration: {str(e)}"
+        logger.error(f"{error_msg}\nConfig ID: {config_id}")
+        # Don't cleanup on error - keep file for debugging
+        if config_path.exists():
+            logger.info(f"Failed config preserved at {config_path} for debugging")
+        raise Exception(error_msg)
 
-def cleanup_cloud_init(path: str) -> None:
+def cleanup_cloud_init(path: str, config_id: str) -> None:
     """Clean up cloud-init configuration file.
     
     Args:
         path: Path to cloud-init configuration file
+        config_id: Configuration ID for logging
     """
     try:
         Path(path).unlink()
-    except Exception:
-        pass
+        logger.debug(f"Cleaned up cloud-init configuration {config_id}")
+    except Exception as e:
+        logger.warning(f"Failed to cleanup cloud-init configuration {config_id}: {e}")

provider/vm/multipass.py

@@ -158,20 +158,22 @@ class MultipassProvider(VMProvider):
         """
         multipass_name = f"golem-{config.name}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
         await self.name_mapper.add_mapping(config.name, multipass_name)
+        cloud_init_path = None
+        config_id = None
 
         # Verify resources are properly allocated
         if not self.resource_tracker.can_accept_resources(config.resources):
             raise VMCreateError("Resources not properly allocated or insufficient")
 
-        # Generate cloud-init config with requestor's public key
-        cloud_init_path = generate_cloud_init(
-            hostname=config.name,
-            ssh_key=config.ssh_key
-        )
-
         try:
+            # Generate cloud-init config with requestor's public key
+            cloud_init_path, config_id = generate_cloud_init(
+                hostname=config.name,
+                ssh_key=config.ssh_key
+            )
+
             # Launch VM
-            logger.process(f"🚀 Launching VM {multipass_name}")
+            logger.process(f"🚀 Launching VM {multipass_name} with config {config_id}")
             launch_cmd = [
                 "launch",
                 config.image,
@@ -237,7 +239,8 @@ class MultipassProvider(VMProvider):
 
         finally:
             # Cleanup cloud-init file
-            cleanup_cloud_init(cloud_init_path)
+            if cloud_init_path and config_id:
+                cleanup_cloud_init(cloud_init_path, config_id)
 
     def _verify_vm_exists(self, vm_id: str) -> bool:
         """Check if VM exists in multipass.