use reqwest::Method;
use serde::{Deserialize, Serialize};
use crate::Traced;
use crate::error::SdkError;
use super::ingest::expect_json;
use super::merge::{MergeConflict, MergeReport, MergeStats, Signature, expect_json_or_conflict};
use super::{ArtifactStorageClient, decode_empty};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceInfo {
pub id: String,
pub ref_name: String,
pub principal: String,
pub base: String,
pub base_ref: Option<String>,
pub head: String,
pub created_at_secs: u64,
pub lease_secs: u64,
pub lease_due_ms: Option<u64>,
pub pinned: bool,
#[serde(default)]
pub shared_target: Option<String>,
}
#[derive(Clone, Debug, Default, Serialize)]
pub struct CreateWorkspaceRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub base: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_target: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reconcile_policy: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub surface: Option<String>,
#[serde(skip_serializing_if = "std::ops::Not::not")]
pub read_only: bool,
}
#[derive(Clone, Debug, Deserialize)]
pub struct WorkspaceHeartbeat {
pub lease_due_ms: Option<u64>,
pub pinned: bool,
}
#[derive(Clone, Debug, Default, Serialize)]
pub struct PromoteWorkspaceRequest {
pub branch: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub expect_oid: Option<String>,
#[serde(skip_serializing_if = "std::ops::Not::not")]
pub full_history: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub author: Option<Signature>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PromoteWorkspaceResponse {
pub commit: String,
pub ref_name: String,
pub created: bool,
pub squashed: bool,
#[serde(default)]
pub merged: bool,
#[serde(default)]
pub fast_forwarded: bool,
}
#[derive(Clone, Debug)]
pub enum PromoteOutcome {
Promoted(PromoteWorkspaceResponse),
Conflicted(MergeReport),
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PromotePreflight {
pub target_ref: String,
pub target_head: Option<String>,
pub workspace_base: String,
pub workspace_head: String,
pub moved: bool,
pub fast_forward: bool,
}
#[derive(Clone, Debug, Default, Serialize)]
pub struct SyncWorkspaceRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub author: Option<Signature>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SyncWorkspaceResponse {
pub workspace_head: String,
pub target_head: String,
pub base: String,
pub clean: bool,
pub up_to_date: bool,
pub fast_forwarded: bool,
pub changed_paths: u64,
pub conflicts: Vec<MergeConflict>,
pub stats: MergeStats,
}
#[derive(Clone, Debug, Deserialize)]
pub struct RefStatus {
pub ref_name: String,
pub oid: Option<String>,
pub generation: u64,
}
#[derive(Clone, Debug, Deserialize)]
pub struct TreePage {
pub entries: Vec<TreeEntry>,
pub truncated: bool,
pub next_after: Option<String>,
}
#[derive(Clone, Debug, Deserialize)]
pub struct TreeEntry {
pub name: String,
pub oid: String,
pub mode: u32,
pub size: Option<u64>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceFleetItem {
pub id: String,
pub repo: String,
pub status: String,
pub mode: String,
#[serde(default)]
pub created_by: Option<WorkspaceActor>,
pub base: String,
#[serde(default)]
pub base_ref: Option<String>,
pub head: String,
pub created_at_secs: u64,
#[serde(default)]
pub lease_secs: u64,
#[serde(default)]
pub lease_due_ms: Option<u64>,
#[serde(default)]
pub shared_target: Option<String>,
#[serde(default)]
pub snapshot_count: u64,
#[serde(default)]
pub last_snapshot_ms: Option<u64>,
#[serde(default)]
pub last_heartbeat_ms: Option<u64>,
#[serde(default)]
pub mounted_on: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceActor {
pub name: String,
pub kind: String,
}
#[derive(Clone, Debug, Default, Deserialize)]
pub struct WorkspaceFleetCounts {
pub total: u64,
pub live: u64,
pub detached: u64,
pub gap: u64,
pub idle: u64,
pub truncated: bool,
}
#[derive(Clone, Debug, Deserialize)]
pub struct WorkspaceFleetPage {
pub project: String,
pub items: Vec<WorkspaceFleetItem>,
pub counts: WorkspaceFleetCounts,
pub truncated: bool,
#[serde(default)]
pub next_after: Option<String>,
}
#[derive(Clone, Copy, Debug, Default)]
pub struct WorkspaceFleetQuery<'a> {
pub repo: Option<&'a str>,
pub q: Option<&'a str>,
pub principal_self: bool,
pub after: Option<&'a str>,
pub limit: Option<usize>,
}
impl ArtifactStorageClient {
pub async fn create_workspace(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
request: &CreateWorkspaceRequest,
) -> Result<Traced<WorkspaceInfo>, SdkError> {
let (req, trace_id) = self.git_request(
Method::POST,
project_id,
repo,
Some("workspaces"),
git_username,
git_token,
)?;
let info = expect_json(req.json(request).send().await?).await?;
Ok(Traced::new(trace_id, info))
}
pub async fn get_workspace(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
workspace_id: &str,
) -> Result<Traced<WorkspaceInfo>, SdkError> {
let (req, trace_id) = self.git_request(
Method::GET,
project_id,
repo,
Some(&format!("workspaces/{workspace_id}")),
git_username,
git_token,
)?;
let info = expect_json(req.send().await?).await?;
Ok(Traced::new(trace_id, info))
}
pub async fn workspace_fleet(
&self,
project_id: &str,
git_username: &str,
git_token: &str,
query: &WorkspaceFleetQuery<'_>,
) -> Result<Traced<WorkspaceFleetPage>, SdkError> {
let mut params = url::form_urlencoded::Serializer::new(String::new());
if let Some(repo) = query.repo {
params.append_pair("repo", repo);
}
if let Some(q) = query.q {
params.append_pair("q", q);
}
if query.principal_self {
params.append_pair("principal", "self");
}
if let Some(after) = query.after {
params.append_pair("after", after);
}
if let Some(limit) = query.limit {
params.append_pair("limit", &limit.to_string());
}
let params = params.finish();
let suffix = if params.is_empty() {
"workspaces".to_string()
} else {
format!("workspaces?{params}")
};
let (req, trace_id) =
self.project_git_request(Method::GET, project_id, &suffix, git_username, git_token);
let page = expect_json(req.send().await?).await?;
Ok(Traced::new(trace_id, page))
}
pub async fn workspace_fleet_all(
&self,
project_id: &str,
git_username: &str,
git_token: &str,
query: &WorkspaceFleetQuery<'_>,
) -> Result<Traced<Vec<WorkspaceFleetItem>>, SdkError> {
let mut items = Vec::new();
let mut after: Option<String> = query.after.map(str::to_string);
loop {
let page = self
.workspace_fleet(
project_id,
git_username,
git_token,
&WorkspaceFleetQuery {
after: after.as_deref(),
..*query
},
)
.await?;
let trace_id = page.trace_id.clone();
let page = page.into_inner();
items.extend(page.items);
if !page.truncated {
return Ok(Traced::new(trace_id, items));
}
let Some(next) = page.next_after else {
return Ok(Traced::new(trace_id, items));
};
after = Some(next);
}
}
pub async fn list_workspaces(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
) -> Result<Traced<Vec<WorkspaceInfo>>, SdkError> {
let (req, trace_id) = self.git_request(
Method::GET,
project_id,
repo,
Some("workspaces"),
git_username,
git_token,
)?;
let list = expect_json(req.send().await?).await?;
Ok(Traced::new(trace_id, list))
}
pub async fn workspace_heartbeat(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
workspace_id: &str,
) -> Result<Traced<WorkspaceHeartbeat>, SdkError> {
let (req, trace_id) = self.git_request(
Method::POST,
project_id,
repo,
Some(&format!("workspaces/{workspace_id}/heartbeat")),
git_username,
git_token,
)?;
let hb = expect_json(req.send().await?).await?;
Ok(Traced::new(trace_id, hb))
}
pub async fn workspace_promote(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
workspace_id: &str,
request: &PromoteWorkspaceRequest,
) -> Result<Traced<PromoteOutcome>, SdkError> {
let (req, trace_id) = self.git_request(
Method::POST,
project_id,
repo,
Some(&format!("workspaces/{workspace_id}/promote")),
git_username,
git_token,
)?;
let outcome = expect_json_or_conflict::<PromoteWorkspaceResponse, MergeReport>(
req.json(request).send().await?,
)
.await?
.map(PromoteOutcome::Promoted)
.unwrap_or_else(PromoteOutcome::Conflicted);
Ok(Traced::new(trace_id, outcome))
}
pub async fn workspace_promote_preflight(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
workspace_id: &str,
target: &str,
) -> Result<Traced<PromotePreflight>, SdkError> {
let suffix = format!(
"workspaces/{workspace_id}/promote/preflight?target={}",
url::form_urlencoded::byte_serialize(target.as_bytes()).collect::<String>()
);
let (req, trace_id) = self.git_request(
Method::GET,
project_id,
repo,
Some(&suffix),
git_username,
git_token,
)?;
let preflight = expect_json(req.send().await?).await?;
Ok(Traced::new(trace_id, preflight))
}
pub async fn workspace_sync(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
workspace_id: &str,
request: &SyncWorkspaceRequest,
) -> Result<Traced<SyncWorkspaceResponse>, SdkError> {
let (req, trace_id) = self.git_request(
Method::POST,
project_id,
repo,
Some(&format!("workspaces/{workspace_id}/sync")),
git_username,
git_token,
)?;
let resp = expect_json_or_conflict::<SyncWorkspaceResponse, SyncWorkspaceResponse>(
req.json(request).send().await?,
)
.await?
.unwrap_or_else(|conflicted| conflicted);
Ok(Traced::new(trace_id, resp))
}
pub async fn delete_workspace(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
workspace_id: &str,
) -> Result<Traced<()>, SdkError> {
let (req, trace_id) = self.git_request(
Method::DELETE,
project_id,
repo,
Some(&format!("workspaces/{workspace_id}")),
git_username,
git_token,
)?;
decode_empty(req.send().await?, trace_id).await
}
pub async fn ref_status(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
refspec: &str,
) -> Result<Traced<RefStatus>, SdkError> {
let suffix = format!(
"ref-status?ref={}",
url::form_urlencoded::byte_serialize(refspec.as_bytes()).collect::<String>()
);
let (req, trace_id) = self.git_request(
Method::GET,
project_id,
repo,
Some(&suffix),
git_username,
git_token,
)?;
let status = expect_json(req.send().await?).await?;
Ok(Traced::new(trace_id, status))
}
pub async fn list_tree_page(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
version: &str,
dir_path: &str,
after: Option<&str>,
limit: usize,
) -> Result<Traced<TreePage>, SdkError> {
let enc = |s: &str| url::form_urlencoded::byte_serialize(s.as_bytes()).collect::<String>();
let mut suffix = if dir_path.is_empty() {
format!("tree?version={}&limit={limit}", enc(version))
} else {
format!("tree/{}?version={}&limit={limit}", dir_path, enc(version))
};
if let Some(after) = after {
suffix.push_str(&format!("&after={}", enc(after)));
}
let (req, trace_id) = self.git_request(
Method::GET,
project_id,
repo,
Some(&suffix),
git_username,
git_token,
)?;
let page = expect_json(req.send().await?).await?;
Ok(Traced::new(trace_id, page))
}
pub async fn get_file_bytes(
&self,
project_id: &str,
repo: &str,
git_username: &str,
git_token: &str,
version: &str,
file_path: &str,
) -> Result<Traced<Vec<u8>>, SdkError> {
let suffix = format!(
"files/{file_path}?version={}",
url::form_urlencoded::byte_serialize(version.as_bytes()).collect::<String>()
);
let (req, trace_id) = self.git_request(
Method::GET,
project_id,
repo,
Some(&suffix),
git_username,
git_token,
)?;
let resp = req.send().await?;
if !resp.status().is_success() {
let status = resp.status();
let body = resp.text().await.unwrap_or_default();
return Err(SdkError::ServerError {
status,
message: body,
});
}
let bytes = resp.bytes().await?.to_vec();
Ok(Traced::new(trace_id, bytes))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn promote_response_tolerates_old_servers() {
let body = r#"{"commit": "aa", "ref_name": "refs/heads/main", "created": false, "squashed": true}"#;
let resp: PromoteWorkspaceResponse = serde_json::from_str(body).unwrap();
assert!(resp.squashed);
assert!(!resp.merged);
assert!(!resp.fast_forwarded);
}
#[test]
fn fleet_page_decodes_server_shape() {
let body = r#"{
"project": "p1",
"items": [{
"id": "aabbccdd", "repo": "p1/demo", "status": "live", "mode": "shared-rw",
"created_by": {"name": "user:u1", "kind": "human"},
"base": "1111111111111111111111111111111111111111",
"base_ref": "refs/heads/main",
"head": "2222222222222222222222222222222222222222",
"created_at_secs": 1751000000,
"lease_secs": 3600,
"lease_due_ms": 1751003600000,
"shared_target": "main",
"snapshot_count": 3,
"last_snapshot_ms": 1751000500000,
"last_heartbeat_ms": 1751000600000,
"mounted_on": "sandbox-42"
}],
"counts": {"total": 1, "live": 1, "detached": 0, "gap": 0, "idle": 0, "truncated": false},
"truncated": true,
"next_after": "aabbccdd"
}"#;
let page: WorkspaceFleetPage = serde_json::from_str(body).unwrap();
assert_eq!(page.project, "p1");
assert_eq!(page.counts.total, 1);
assert!(page.truncated);
assert_eq!(page.next_after.as_deref(), Some("aabbccdd"));
let item = &page.items[0];
assert_eq!(item.id, "aabbccdd");
assert_eq!(item.repo, "p1/demo");
assert_eq!(item.status, "live");
assert_eq!(item.mode, "shared-rw");
assert_eq!(item.created_by.as_ref().unwrap().name, "user:u1");
assert_eq!(item.created_by.as_ref().unwrap().kind, "human");
assert_eq!(item.base_ref.as_deref(), Some("refs/heads/main"));
assert_eq!(item.lease_secs, 3600);
assert_eq!(item.lease_due_ms, Some(1751003600000));
assert_eq!(item.snapshot_count, 3);
assert_eq!(item.mounted_on.as_deref(), Some("sandbox-42"));
}
#[test]
fn fleet_item_tolerates_omitted_optionals() {
let body = r#"{
"project": "p1",
"items": [{
"id": "ee", "repo": "p1/demo", "status": "detached", "mode": "default",
"base": "1111111111111111111111111111111111111111",
"head": "1111111111111111111111111111111111111111",
"created_at_secs": 1751000000,
"snapshot_count": 0
}],
"counts": {"total": 1, "live": 0, "detached": 1, "gap": 0, "idle": 0, "truncated": false},
"truncated": false
}"#;
let page: WorkspaceFleetPage = serde_json::from_str(body).unwrap();
let item = &page.items[0];
assert!(item.created_by.is_none(), "unbound workspace");
assert!(item.base_ref.is_none());
assert_eq!(item.lease_secs, 0, "old servers omit lease_secs");
assert!(item.lease_due_ms.is_none(), "omitted lease row = pinned");
assert!(item.shared_target.is_none());
assert!(item.last_snapshot_ms.is_none());
assert!(item.last_heartbeat_ms.is_none());
assert!(item.mounted_on.is_none());
assert!(page.next_after.is_none());
}
#[test]
fn sync_response_decodes_server_shape() {
let body = r#"{
"workspace_head": "ws1", "target_head": "t1", "base": "t1",
"clean": false, "up_to_date": false, "fast_forwarded": false,
"changed_paths": 2,
"conflicts": [{"path": "f", "kind": "content", "potential": false,
"ours": {"mode": 33188, "oid": "o"}, "base": {"mode": 33188, "oid": "b"},
"theirs": {"mode": 33188, "oid": "t"}}],
"stats": {"trees_read": 4, "entries_compared": 9, "blobs_merged": 1, "wall_ms": 0.7}
}"#;
let resp: SyncWorkspaceResponse = serde_json::from_str(body).unwrap();
assert!(!resp.clean);
assert_eq!(resp.base, "t1");
assert_eq!(resp.conflicts.len(), 1);
assert_eq!(resp.conflicts[0].kind, "content");
}
}