request-vm-on-golem 0.1.24__py3-none-any.whl → 0.1.27__py3-none-any.whl

requestor/services/vm_service.py

@@ -0,0 +1,218 @@
+"""VM management service."""
+from typing import Dict, List, Optional
+from datetime import datetime
+
+from ..provider.client import ProviderClient
+from ..errors import RequestorError, VMError
+from .database_service import DatabaseService
+from .ssh_service import SSHService
+
+class VMService:
+    """Service for VM operations."""
+    
+    def __init__(
+        self,
+        db_service: DatabaseService,
+        ssh_service: SSHService,
+        provider_client: Optional[ProviderClient] = None
+    ):
+        self.db = db_service
+        self.ssh_service = ssh_service
+        self.provider_client = provider_client
+
+    async def create_vm(
+        self,
+        name: str,
+        cpu: int,
+        memory: int,
+        storage: int,
+        provider_ip: str,
+        ssh_key: str
+    ) -> Dict:
+        """Create a new VM with validation and error handling."""
+        try:
+            # Check if VM name already exists
+            existing_vm = await self.db.get_vm(name)
+            if existing_vm:
+                raise VMError(f"VM with name '{name}' already exists")
+
+            # Create VM on provider
+            vm = await self.provider_client.create_vm(
+                name=name,
+                cpu=cpu,
+                memory=memory,
+                storage=storage,
+                ssh_key=ssh_key
+            )
+
+            # Get VM access info
+            access_info = await self.provider_client.get_vm_access(vm['id'])
+
+            # Save VM details to database
+            config = {
+                'cpu': cpu,
+                'memory': memory,
+                'storage': storage,
+                'ssh_port': access_info['ssh_port']
+            }
+            await self.db.save_vm(
+                name=name,
+                provider_ip=provider_ip,
+                vm_id=access_info['vm_id'],
+                config=config
+            )
+
+            return {
+                'name': name,
+                'provider_ip': provider_ip,
+                'vm_id': access_info['vm_id'],
+                'config': config,
+                'status': 'running'
+            }
+
+        except Exception as e:
+            raise VMError(f"Failed to create VM: {str(e)}")
+
+    async def destroy_vm(self, name: str) -> None:
+        """Destroy a VM and clean up resources."""
+        try:
+            # Get VM details
+            vm = await self.db.get_vm(name)
+            if not vm:
+                raise VMError(f"VM '{name}' not found")
+
+            try:
+                # Destroy VM on provider
+                await self.provider_client.destroy_vm(vm['vm_id'])
+            except Exception as e:
+                if "Not Found" not in str(e):
+                    raise
+
+            # Remove from database
+            await self.db.delete_vm(name)
+
+        except Exception as e:
+            raise VMError(f"Failed to destroy VM: {str(e)}")
+
+    async def start_vm(self, name: str) -> None:
+        """Start a stopped VM."""
+        try:
+            # Get VM details
+            vm = await self.db.get_vm(name)
+            if not vm:
+                raise VMError(f"VM '{name}' not found")
+
+            # Start VM on provider
+            await self.provider_client.start_vm(vm['vm_id'])
+            
+            # Update status in database
+            await self.db.update_vm_status(name, "running")
+
+        except Exception as e:
+            raise VMError(f"Failed to start VM: {str(e)}")
+
+    async def stop_vm(self, name: str) -> None:
+        """Stop a running VM."""
+        try:
+            # Get VM details
+            vm = await self.db.get_vm(name)
+            if not vm:
+                raise VMError(f"VM '{name}' not found")
+
+            # Stop VM on provider
+            await self.provider_client.stop_vm(vm['vm_id'])
+            
+            # Update status in database
+            await self.db.update_vm_status(name, "stopped")
+
+        except Exception as e:
+            raise VMError(f"Failed to stop VM: {str(e)}")
+
+    async def list_vms(self) -> List[Dict]:
+        """List all VMs with their current status."""
+        try:
+            return await self.db.list_vms()
+        except Exception as e:
+            raise VMError(f"Failed to list VMs: {str(e)}")
+
+    async def get_vm(self, name: str) -> Optional[Dict]:
+        """Get VM details by name."""
+        try:
+            vm = await self.db.get_vm(name)
+            if not vm:
+                return None
+            return vm
+        except Exception as e:
+            raise VMError(f"Failed to get VM details: {str(e)}")
+
+    def format_vm_row(self, vm: Dict, colorize: bool = False) -> List:
+        """Format VM information for display."""
+        from click import style
+
+        key_pair = self.ssh_service.get_key_pair_sync()
+        connect_command = self.ssh_service.format_ssh_command(
+            host=vm['provider_ip'],
+            port=vm['config'].get('ssh_port', 'N/A'),
+            private_key_path=key_pair.private_key.absolute()
+        )
+
+        row = [
+            vm['name'],
+            vm['status'],
+            vm['provider_ip'],
+            vm['config'].get('ssh_port', 'N/A'),
+            vm['config']['cpu'],
+            vm['config']['memory'],
+            vm['config']['storage'],
+            connect_command,
+            vm['created_at']
+        ]
+
+        if colorize:
+            # Format status with color and icon
+            status = row[1]
+            if status == "running":
+                row[1] = style("● " + status, fg="green", bold=True)
+            elif status == "stopped":
+                row[1] = style("● " + status, fg="yellow", bold=True)
+            else:
+                row[1] = style("● " + status, fg="red", bold=True)
+
+            # Format other columns
+            row[0] = style(row[0], fg="cyan")  # Name
+            row[2] = style(row[2], fg="cyan")  # IP
+            row[3] = style(str(row[3]), fg="cyan")  # Port
+
+        return row
+
+    @property
+    def vm_headers(self) -> List[str]:
+        """Get headers for VM display."""
+        return [
+            "Name",
+            "Status",
+            "IP Address",
+            "SSH Port",
+            "CPU",
+            "Memory (GB)",
+            "Storage (GB)",
+            "Connect Command",
+            "Created"
+        ]
+
+    async def get_vm_stats(self, name: str) -> Dict:
+        """Get VM stats by name."""
+        try:
+            vm = await self.db.get_vm(name)
+            if not vm:
+                raise VMError(f"VM '{name}' not found")
+
+            key_pair = await self.ssh_service.get_key_pair()
+
+            return self.ssh_service.get_vm_stats(
+                host=vm['provider_ip'],
+                port=vm['config']['ssh_port'],
+                private_key_path=key_pair.private_key
+            )
+        except Exception as e:
+            raise VMError(f"Failed to get VM stats: {str(e)}")

requestor/ssh/manager.py

@@ -93,6 +93,36 @@ class SSHKeyManager:
             public_key_content=golem_pub_key.read_text().strip()
         )
 
+    def get_key_pair_sync(self) -> KeyPair:
+        """Get the SSH key pair to use (synchronous version)."""
+        logger.debug("Checking for system SSH key at %s", self.system_key_path)
+        system_pub_key = self.system_key_path.parent / 'id_rsa.pub'
+        
+        if self.system_key_path.exists() and system_pub_key.exists():
+            logger.info("Using existing system SSH key")
+            try:
+                return KeyPair(
+                    private_key=self.system_key_path,
+                    public_key=system_pub_key,
+                    private_key_content=self.system_key_path.read_text().strip(),
+                    public_key_content=system_pub_key.read_text().strip()
+                )
+            except (PermissionError, OSError) as e:
+                logger.warning("Could not read system SSH key: %s", e)
+        
+        logger.debug("Using Golem SSH key at %s", self.golem_key_path)
+        if not self.golem_key_path.exists():
+            logger.info("No existing Golem SSH key found, generating new key pair")
+            self._generate_key_pair_sync()
+        
+        golem_pub_key = Path(str(self.golem_key_path) + '.pub')
+        return KeyPair(
+            private_key=self.golem_key_path,
+            public_key=golem_pub_key,
+            private_key_content=self.golem_key_path.read_text().strip(),
+            public_key_content=golem_pub_key.read_text().strip()
+        )
+
     async def get_public_key_content(self) -> str:
         """Get the content of the public key file."""
         key_pair = await self.get_key_pair()
@@ -155,6 +185,38 @@ class SSHKeyManager:
             logger.error("Failed to generate key pair: %s", str(e))
             raise
 
+    def _generate_key_pair_sync(self):
+        """Generate a new RSA key pair for Golem VMs (synchronous version)."""
+        logger.debug("Generating new RSA key pair")
+        try:
+            private_key = rsa.generate_private_key(
+                public_exponent=65537,
+                key_size=2048,
+                backend=default_backend()
+            )
+            private_pem = private_key.private_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PrivateFormat.PKCS8,
+                encryption_algorithm=serialization.NoEncryption()
+            )
+            self.golem_key_path.write_bytes(private_pem)
+            if os.name == 'posix':
+                os.chmod(self.golem_key_path, 0o600)
+
+            public_key = private_key.public_key()
+            public_pem = public_key.public_bytes(
+                encoding=serialization.Encoding.OpenSSH,
+                format=serialization.PublicFormat.OpenSSH
+            )
+            pub_key_path = Path(str(self.golem_key_path) + '.pub')
+            pub_key_path.write_bytes(public_pem)
+            if os.name == 'posix':
+                os.chmod(pub_key_path, 0o644)
+            logger.info("Successfully generated and saved SSH key pair")
+        except Exception as e:
+            logger.error("Failed to generate key pair: %s", str(e))
+            raise
+
     async def get_private_key_content(self, force_golem_key: bool = False) -> Optional[str]:
         """Get the content of the private key file."""
         key_pair = await self.get_key_pair(force_golem_key)

request_vm_on_golem-0.1.24.dist-info/RECORD

@@ -1,18 +0,0 @@
-requestor/__init__.py,sha256=OqSUAh1uZBMx7GW0MoSMg967PVdmT8XdPJx3QYjwkak,116
-requestor/cli/__init__.py,sha256=e3E4oEGxmGj-STPtFkQwg_qIWhR0JAiAQdw3G1hXciU,37
-requestor/cli/commands.py,sha256=deW4HxJGJvWQCOEvkuPEzkIfSDOSYa2npO4i_4sesCo,24283
-requestor/config.py,sha256=3e0xAuteZ3JiE6uWHipQLQQklGN59hiqdqZUT2mUutM,2146
-requestor/db/__init__.py,sha256=Gm5DfWls6uvCZZ3HGGnyRHswbUQdeA5OGN8yPwH0hc8,88
-requestor/db/sqlite.py,sha256=kqutQMs3srcZHa5kI1cbHvOYr66cCfQCb2xuioNAbLc,4638
-requestor/errors.py,sha256=wVpHBuYgQx5pTe_SamugfK-k768noikY1RxvPOjQGko,665
-requestor/provider/__init__.py,sha256=fmW23aYUVciF8-gmBZkG-PLhn22upmcDzdPfAOLHG6g,103
-requestor/provider/client.py,sha256=OUP7CoOCCtKD6DB9eqFkOXK6A2BLFdM4DWSkoulJQxg,3213
-requestor/run.py,sha256=mFqoP93KuRpQZ8pmzP5pHvByaDjHJ9xRYRjYC77s6bg,1386
-requestor/ssh/__init__.py,sha256=hNgSqJ5s1_AwwxVRyFjUqh_LTBpI4Hmzq0F-f_wXN9g,119
-requestor/ssh/manager.py,sha256=h-93AXFJqzGo2lNTG2u-q4ivU9cCFeNDhYN55skPLBo,6566
-requestor/utils/logging.py,sha256=oFNpO8pJboYM8Wp7g3HOU4HFyBTKypVdY15lUiz1a4I,3721
-requestor/utils/spinner.py,sha256=PUHJdTD9jpUHur__01_qxXy87WFfNmjQbD_sLG-KlGo,2459
-request_vm_on_golem-0.1.24.dist-info/METADATA,sha256=969OAj0KxwHXeI6BWZkfiLbjyO-sYdBPxlDyEP9QyTE,9060
-request_vm_on_golem-0.1.24.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-request_vm_on_golem-0.1.24.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
-request_vm_on_golem-0.1.24.dist-info/RECORD,,