daytona_client/

workspace.rs

//! Workspace management operations

use tracing::{debug, info};
use uuid::Uuid;

use crate::{client::DaytonaClient, error::Result, models::workspace::*};

/// Manager for workspace operations
pub struct WorkspaceManager<'a> {
    client: &'a DaytonaClient,
}

impl<'a> WorkspaceManager<'a> {
    /// Create a new workspace manager
    pub fn new(client: &'a DaytonaClient) -> Self {
        Self { client }
    }

    /// Create a new workspace
    pub async fn create(&self, params: CreateWorkspaceParams) -> Result<Workspace> {
        info!("Creating new workspace: {}", params.name);

        let response = self
            .client
            .build_request(reqwest::Method::POST, "/workspace")
            .json(&params)
            .send()
            .await?;

        let workspace = self.client.handle_response::<Workspace>(response).await?;
        info!("Created workspace: {} ({})", workspace.name, workspace.id);

        Ok(workspace)
    }

    /// Get workspace by ID
    pub async fn get(&self, workspace_id: &Uuid) -> Result<Workspace> {
        debug!("Getting workspace: {}", workspace_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/workspace/{}", workspace_id),
            )
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// List all workspaces
    pub async fn list(&self) -> Result<Vec<Workspace>> {
        debug!("Listing workspaces");

        let response = self
            .client
            .build_request(reqwest::Method::GET, "/workspace")
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Update workspace
    pub async fn update(
        &self,
        workspace_id: &Uuid,
        params: UpdateWorkspaceParams,
    ) -> Result<Workspace> {
        info!("Updating workspace: {}", workspace_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::PUT,
                &format!("/workspace/{}", workspace_id),
            )
            .json(&params)
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Delete workspace
    pub async fn delete(&self, workspace_id: &Uuid) -> Result<()> {
        self.delete_with_force(workspace_id, false).await
    }

    /// Delete workspace with force option
    pub async fn delete_with_force(&self, workspace_id: &Uuid, force: bool) -> Result<()> {
        info!("Deleting workspace: {} (force: {})", workspace_id, force);

        let url = if force {
            format!("/workspace/{}?force=true", workspace_id)
        } else {
            format!("/workspace/{}", workspace_id)
        };

        let response = self
            .client
            .build_request(reqwest::Method::DELETE, &url)
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to delete workspace: {}",
                error_text
            )))
        }
    }

    /// Start workspace
    pub async fn start(&self, workspace_id: &Uuid) -> Result<()> {
        info!("Starting workspace: {}", workspace_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/start", workspace_id),
            )
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to start workspace: {}",
                error_text
            )))
        }
    }

    /// Stop workspace
    pub async fn stop(&self, workspace_id: &Uuid) -> Result<()> {
        info!("Stopping workspace: {}", workspace_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/stop", workspace_id),
            )
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to stop workspace: {}",
                error_text
            )))
        }
    }

    /// Archive workspace
    pub async fn archive(&self, workspace_id: &Uuid) -> Result<()> {
        info!("Archiving workspace: {}", workspace_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/archive", workspace_id),
            )
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to archive workspace: {}",
                error_text
            )))
        }
    }

    /// Restore archived workspace
    pub async fn restore(&self, workspace_id: &Uuid) -> Result<()> {
        info!("Restoring workspace: {}", workspace_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/restore", workspace_id),
            )
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to restore workspace: {}",
                error_text
            )))
        }
    }

    /// Create workspace backup
    pub async fn backup(
        &self,
        workspace_id: &Uuid,
        name: String,
        description: Option<String>,
    ) -> Result<WorkspaceBackup> {
        info!("Creating backup for workspace: {}", workspace_id);

        let body = serde_json::json!({
            "name": name,
            "description": description
        });

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/backup", workspace_id),
            )
            .json(&body)
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// List workspace backups
    pub async fn list_backups(&self, workspace_id: &Uuid) -> Result<Vec<WorkspaceBackup>> {
        debug!("Listing backups for workspace: {}", workspace_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/workspace/{}/backup", workspace_id),
            )
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Restore from backup
    pub async fn restore_from_backup(&self, workspace_id: &Uuid, backup_id: &Uuid) -> Result<()> {
        info!(
            "Restoring workspace {} from backup {}",
            workspace_id, backup_id
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/backup/{}/restore", workspace_id, backup_id),
            )
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to restore from backup: {}",
                error_text
            )))
        }
    }

    /// Get port preview URL
    pub async fn get_port_preview(&self, workspace_id: &Uuid, port: u16) -> Result<PortPreview> {
        debug!(
            "Getting port preview for workspace {} port {}",
            workspace_id, port
        );

        let response = self
            .client
            .build_request(
                reqwest::Method::GET,
                &format!("/workspace/{}/port/{}/preview", workspace_id, port),
            )
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Create port preview
    pub async fn create_port_preview(
        &self,
        workspace_id: &Uuid,
        port: u16,
        public: bool,
    ) -> Result<PortPreview> {
        info!(
            "Creating port preview for workspace {} port {}",
            workspace_id, port
        );

        let body = serde_json::json!({ "public": public });

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/port/{}/preview", workspace_id, port),
            )
            .json(&body)
            .send()
            .await?;

        self.client.handle_response(response).await
    }

    /// Get build logs for a workspace
    pub async fn get_build_logs(&self, workspace_id: &Uuid, follow: bool) -> Result<String> {
        debug!(
            "Getting build logs for workspace: {} (follow: {})",
            workspace_id, follow
        );

        let url = if follow {
            format!("/workspace/{}/build-logs?follow=true", workspace_id)
        } else {
            format!("/workspace/{}/build-logs", workspace_id)
        };

        let response = self
            .client
            .build_request(reqwest::Method::GET, &url)
            .send()
            .await?;

        if response.status().is_success() {
            Ok(response.text().await?)
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to get build logs: {}",
                error_text
            )))
        }
    }

    /// Replace labels for a workspace
    pub async fn replace_labels(
        &self,
        workspace_id: &Uuid,
        labels: std::collections::HashMap<String, String>,
    ) -> Result<()> {
        info!("Replacing labels for workspace: {}", workspace_id);

        let response = self
            .client
            .build_request(
                reqwest::Method::PUT,
                &format!("/workspace/{}/labels", workspace_id),
            )
            .json(&labels)
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to replace labels: {}",
                error_text
            )))
        }
    }

    /// Set auto-archive interval for a workspace
    pub async fn set_auto_archive_interval(&self, workspace_id: &Uuid, minutes: u32) -> Result<()> {
        info!(
            "Setting auto-archive interval for workspace {}: {} minutes",
            workspace_id, minutes
        );

        let body = serde_json::json!({ "minutes": minutes });

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/auto-archive", workspace_id),
            )
            .json(&body)
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to set auto-archive interval: {}",
                error_text
            )))
        }
    }

    /// Set auto-stop interval for a workspace
    pub async fn set_autostop_interval(&self, workspace_id: &Uuid, minutes: u32) -> Result<()> {
        info!(
            "Setting auto-stop interval for workspace {}: {} minutes",
            workspace_id, minutes
        );

        let body = serde_json::json!({ "minutes": minutes });

        let response = self
            .client
            .build_request(
                reqwest::Method::POST,
                &format!("/workspace/{}/auto-stop", workspace_id),
            )
            .json(&body)
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to set auto-stop interval: {}",
                error_text
            )))
        }
    }

    /// Update public status of a workspace
    pub async fn update_public_status(&self, workspace_id: &Uuid, is_public: bool) -> Result<()> {
        info!(
            "Updating public status for workspace {}: {}",
            workspace_id, is_public
        );

        let body = serde_json::json!({ "public": is_public });

        let response = self
            .client
            .build_request(
                reqwest::Method::PATCH,
                &format!("/workspace/{}/public", workspace_id),
            )
            .json(&body)
            .send()
            .await?;

        if response.status().is_success() {
            Ok(())
        } else {
            let error_text = response.text().await?;
            Err(crate::error::DaytonaError::RequestFailed(format!(
                "Failed to update public status: {}",
                error_text
            )))
        }
    }

    /// Wait for workspace to reach a specific state
    pub async fn wait_for_state(
        &self,
        workspace_id: &Uuid,
        target_state: WorkspaceState,
        max_wait_seconds: u64,
    ) -> Result<Workspace> {
        let start = std::time::Instant::now();
        let max_duration = std::time::Duration::from_secs(max_wait_seconds);

        loop {
            let workspace = self.get(workspace_id).await?;

            if matches!(workspace.state, ref s if std::mem::discriminant(s) == std::mem::discriminant(&target_state))
            {
                return Ok(workspace);
            }

            if let WorkspaceState::Error = workspace.state {
                return Err(crate::error::DaytonaError::RequestFailed(format!(
                    "Workspace entered error state: {:?}",
                    workspace.error_reason
                )));
            }

            if start.elapsed() > max_duration {
                return Err(crate::error::DaytonaError::RequestFailed(format!(
                    "Timeout waiting for workspace to reach {:?} state",
                    target_state
                )));
            }

            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
        }
    }
}

impl DaytonaClient {
    /// Get workspace manager
    pub fn workspaces(&self) -> WorkspaceManager<'_> {
        WorkspaceManager::new(self)
    }
}