use knotra_vcs::{
OperationId, ProjectId, WorkspaceId, WorkspaceStatus,
model::operation::{
ProjectOperationOutcome, SmartPullDisposition, SmartPullPlan, SmartPullPlanEntry,
SmartPullProgress, SmartPullSkipReason,
},
};
use super::{OperationLeaseId, RetryExclusion};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RetryPreparationId(pub u64);
#[derive(Debug, Clone)]
pub struct SmartPullRetryPreparation {
pub id: RetryPreparationId,
pub workspace_id: WorkspaceId,
pub source_operation_id: OperationId,
pub lease_id: OperationLeaseId,
pub eligible_ids: Vec<ProjectId>,
pub exclusions: Vec<RetryExclusion>,
}
#[derive(Debug, Clone, Default)]
pub enum SyncPhase {
#[default]
Idle,
FetchRunning {
operation_id: OperationId,
lease_id: OperationLeaseId,
started_at: jiff::Timestamp,
total: usize,
done: usize,
completed: Vec<ProjectOutcome>,
operation_results: Vec<knotra_vcs::model::operation::ProjectOperationResult>,
},
Planning,
RetryPreparing,
RetryPreparationFailed,
AwaitingConfirm(SmartPullPlan),
PullRunning {
plan: SmartPullPlan,
lease_id: OperationLeaseId,
started_at: jiff::Timestamp,
completed: Vec<SmartPullProgress>,
},
Done(SyncResult),
}
#[derive(Debug, Clone)]
pub struct SyncResult {
pub per_project: Vec<ProjectOutcome>,
}
#[derive(Debug, Clone)]
pub struct ProjectOutcome {
pub project_name: String,
pub outcome: ProjectOperationOutcome,
pub skip_reason: Option<String>,
pub commands_executed: Vec<String>,
pub stderr: String,
}
impl SyncResult {
pub fn success_count(&self) -> usize {
self.per_project
.iter()
.filter(|p| p.outcome == ProjectOperationOutcome::Succeeded)
.count()
}
pub fn fail_count(&self) -> usize {
self.per_project
.iter()
.filter(|p| p.outcome == ProjectOperationOutcome::Failed)
.count()
}
pub fn skipped_count(&self) -> usize {
self.per_project
.iter()
.filter(|p| p.outcome == ProjectOperationOutcome::Skipped)
.count()
}
}
#[derive(Debug, Default)]
pub struct SyncCenterState {
pub project_selection: std::collections::HashMap<ProjectId, bool>,
pub disposition_overrides: std::collections::HashMap<ProjectId, SmartPullDisposition>,
pub phase: SyncPhase,
pub selected_project_ids: std::collections::HashSet<knotra_vcs::ProjectId>,
pub retry_preparation: Option<SmartPullRetryPreparation>,
pub retry_exclusions: Vec<RetryExclusion>,
next_retry_preparation_id: u64,
}
impl SyncCenterState {
pub fn next_retry_preparation_id(&mut self) -> RetryPreparationId {
self.next_retry_preparation_id = self.next_retry_preparation_id.wrapping_add(1).max(1);
RetryPreparationId(self.next_retry_preparation_id)
}
pub fn set_selection(
&mut self,
projects: &[knotra_vcs::Project],
selected: &std::collections::HashSet<ProjectId>,
) {
self.project_selection.clear();
for p in projects {
self.project_selection
.insert(p.id.clone(), selected.contains(&p.id));
}
}
pub fn is_selected(&self, id: &ProjectId) -> bool {
*self.project_selection.get(id).unwrap_or(&true)
}
pub fn selected_ids(&self) -> Vec<ProjectId> {
self.project_selection
.iter()
.filter(|(_, v)| **v)
.map(|(id, _)| id.clone())
.collect()
}
pub fn build_plan(
&self,
projects: &[knotra_vcs::Project],
workspace_status: Option<&WorkspaceStatus>,
) -> SmartPullPlan {
use knotra_vcs::OperationId;
let statuses = workspace_status
.map(|ws| ws.projects.as_slice())
.unwrap_or(&[]);
let entries: Vec<SmartPullPlanEntry> = projects
.iter()
.map(|p| {
let selected = self.is_selected(&p.id);
let status = statuses.iter().find(|s| s.project_id == p.id);
let is_dirty = status.map(|s| s.working_tree.is_dirty()).unwrap_or(false);
let has_conflict = status.map(|s| s.conflict.has_conflict).unwrap_or(false);
let has_upstream = status.and_then(|s| s.remote.upstream.as_ref()).is_some();
let (disposition, skip_reason) = if !selected {
(
SmartPullDisposition::Excluded,
Some(SmartPullSkipReason::Deselected),
)
} else if status.is_none() {
(
SmartPullDisposition::Excluded,
Some(SmartPullSkipReason::MissingStatus),
)
} else if let Some(d) = self.disposition_overrides.get(&p.id) {
(d.clone(), None)
} else if has_conflict {
(
SmartPullDisposition::Excluded,
Some(SmartPullSkipReason::Conflict),
)
} else if !has_upstream {
(
SmartPullDisposition::Excluded,
Some(SmartPullSkipReason::NoUpstream),
)
} else if is_dirty {
(SmartPullDisposition::FetchOnly, None)
} else {
(SmartPullDisposition::Pull, None)
};
SmartPullPlanEntry {
project_id: p.id.clone(),
project_name: p.name.clone(),
is_dirty,
has_conflict,
skip_reason,
disposition,
}
})
.collect();
SmartPullPlan {
id: OperationId::new(),
entries,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use jiff::Timestamp;
use knotra_vcs::{
ProjectId, WorkspaceStatus,
model::status::{
ConflictStatus, RemoteStatus, RepositoryIdentity, VcsKind, WorkingTreeStatus,
},
};
fn make_project(name: &str) -> knotra_vcs::Project {
knotra_vcs::Project::new(name, "/tmp")
}
fn make_status(
project_id: ProjectId,
uncommitted: u32,
conflict: bool,
) -> knotra_vcs::ProjectStatus {
make_status_with_upstream(project_id, uncommitted, conflict, Some("origin/main"))
}
fn make_status_with_upstream(
project_id: ProjectId,
uncommitted: u32,
conflict: bool,
upstream: Option<&str>,
) -> knotra_vcs::ProjectStatus {
knotra_vcs::ProjectStatus {
project_id,
identity: RepositoryIdentity {
path: "/tmp".into(),
vcs_kind: VcsKind::Git,
},
context: None,
remote: RemoteStatus {
upstream: upstream.map(str::to_owned),
..RemoteStatus::default()
},
working_tree: WorkingTreeStatus {
uncommitted_count: uncommitted,
untracked_count: 0,
},
conflict: ConflictStatus {
has_conflict: conflict,
conflict_count: None,
detection_unavailable: false,
},
refreshed_at: Timestamp::now(),
read_error: None,
}
}
#[test]
fn clean_project_gets_pull_disposition() {
let p = make_project("svc");
let status = make_status(p.id.clone(), 0, false);
let ws = WorkspaceStatus {
projects: vec![status],
last_refresh: None,
};
let mut sc = SyncCenterState::default();
sc.project_selection.insert(p.id.clone(), true);
let plan = sc.build_plan(std::slice::from_ref(&p), Some(&ws));
assert_eq!(plan.entries[0].disposition, SmartPullDisposition::Pull);
}
#[test]
fn dirty_project_defaults_to_fetch_only() {
let p = make_project("svc");
let status = make_status(p.id.clone(), 3, false);
let ws = WorkspaceStatus {
projects: vec![status],
last_refresh: None,
};
let mut sc = SyncCenterState::default();
sc.project_selection.insert(p.id.clone(), true);
let plan = sc.build_plan(std::slice::from_ref(&p), Some(&ws));
assert_eq!(plan.entries[0].disposition, SmartPullDisposition::FetchOnly);
}
#[test]
fn conflicted_project_is_excluded() {
let p = make_project("svc");
let status = make_status(p.id.clone(), 0, true);
let ws = WorkspaceStatus {
projects: vec![status],
last_refresh: None,
};
let mut sc = SyncCenterState::default();
sc.project_selection.insert(p.id.clone(), true);
let plan = sc.build_plan(std::slice::from_ref(&p), Some(&ws));
assert_eq!(plan.entries[0].disposition, SmartPullDisposition::Excluded);
assert_eq!(
plan.entries[0].skip_reason,
Some(SmartPullSkipReason::Conflict)
);
}
#[test]
fn deselected_project_is_excluded() {
let p = make_project("svc");
let mut sc = SyncCenterState::default();
sc.project_selection.insert(p.id.clone(), true);
sc.project_selection.insert(p.id.clone(), false);
let plan = sc.build_plan(std::slice::from_ref(&p), None);
assert_eq!(plan.entries[0].disposition, SmartPullDisposition::Excluded);
assert_eq!(
plan.entries[0].skip_reason,
Some(SmartPullSkipReason::Deselected)
);
}
#[test]
fn selected_project_without_upstream_is_excluded() {
let p = make_project("svc");
let status = make_status_with_upstream(p.id.clone(), 0, false, None);
let ws = WorkspaceStatus {
projects: vec![status],
last_refresh: None,
};
let mut sc = SyncCenterState::default();
sc.project_selection.insert(p.id.clone(), true);
let plan = sc.build_plan(std::slice::from_ref(&p), Some(&ws));
assert_eq!(plan.entries[0].disposition, SmartPullDisposition::Excluded);
assert_eq!(
plan.entries[0].skip_reason,
Some(SmartPullSkipReason::NoUpstream)
);
}
#[test]
fn mixed_upstream_plan_has_pull_and_skipped_no_upstream() {
let p1 = make_project("has-upstream");
let p2 = make_project("no-upstream");
let s1 = make_status(p1.id.clone(), 0, false);
let s2 = make_status_with_upstream(p2.id.clone(), 0, false, None);
let ws = WorkspaceStatus {
projects: vec![s1, s2],
last_refresh: None,
};
let mut sc = SyncCenterState::default();
sc.project_selection.insert(p1.id.clone(), true);
sc.project_selection.insert(p2.id.clone(), true);
let plan = sc.build_plan(&[p1, p2], Some(&ws));
assert_eq!(plan.pull_count(), 1);
assert_eq!(plan.excluded_count(), 1);
assert_eq!(
plan.entries[1].skip_reason,
Some(SmartPullSkipReason::NoUpstream)
);
}
#[test]
fn user_override_stash_and_pull() {
let p = make_project("svc");
let status = make_status(p.id.clone(), 2, false);
let ws = WorkspaceStatus {
projects: vec![status],
last_refresh: None,
};
let mut sc = SyncCenterState::default();
sc.project_selection.insert(p.id.clone(), true);
sc.disposition_overrides
.insert(p.id.clone(), SmartPullDisposition::StashAndPull);
let plan = sc.build_plan(std::slice::from_ref(&p), Some(&ws));
assert_eq!(
plan.entries[0].disposition,
SmartPullDisposition::StashAndPull
);
}
#[test]
fn plan_pull_count() {
let p1 = make_project("a");
let p2 = make_project("b");
let p3 = make_project("c");
let s1 = make_status(p1.id.clone(), 0, false);
let s2 = make_status(p2.id.clone(), 1, false); let s3 = make_status(p3.id.clone(), 0, true); let ws = WorkspaceStatus {
projects: vec![s1, s2, s3],
last_refresh: None,
};
let mut sc = SyncCenterState::default();
sc.project_selection.insert(p1.id.clone(), true);
sc.project_selection.insert(p2.id.clone(), true);
sc.project_selection.insert(p3.id.clone(), true);
let plan = sc.build_plan(&[p1, p2, p3], Some(&ws));
assert_eq!(plan.pull_count(), 1);
assert_eq!(plan.excluded_count(), 1);
}
}