git-next/src/server/actors/repo/branch.rs

255 lines
7.7 KiB
Rust
Raw Normal View History

use actix::prelude::*;
use kxio::network::{self, Network};
use tracing::{error, info, warn};
use crate::server::{
actors::repo::ValidateRepo,
config::{self, RepoConfig, RepoDetails},
forge::{self, CommitHistories},
git::Git,
types::ResetForce,
};
use super::{RepoActor, StartMonitoring};
2024-04-11 07:46:30 +01:00
#[tracing::instrument(fields(forge_name = %repo_details.forge.name, repo_name = %repo_details.name), skip_all)]
pub async fn validate_positions(
repo_details: config::RepoDetails,
config: config::RepoConfig,
addr: Addr<RepoActor>,
git: Git,
net: network::Network,
) {
// Collect Commit Histories for `main`, `next` and `dev` branches
let commit_histories = get_commit_histories(&repo_details, &config, &net).await;
let commit_histories = match commit_histories {
Ok(commit_histories) => commit_histories,
Err(err) => {
error!(?err, "Failed to get commit histories");
revalidate_positions(addr).await;
return;
}
};
// Validations
let Some(main) = commit_histories.main.first().cloned() else {
warn!("No commits on main branch '{}'", config.branches().main());
revalidate_positions(addr).await;
return;
};
// verify that next is an ancestor of dev, and force update to it main if it isn't
let Some(next) = commit_histories.next.first().cloned() else {
warn!("No commits on next branch '{}", config.branches().next());
revalidate_positions(addr).await;
return;
};
let next_is_ancestor_of_dev = commit_histories.dev.iter().any(|dev| dev == &next);
if !next_is_ancestor_of_dev {
info!("Next is not an ancestor of dev - resetting next to main");
reset_next_to_main(next, main, &repo_details, &config, &git);
revalidate_positions(addr).await;
return;
}
let next_commits = commit_histories
.next
.into_iter()
.take(2)
.collect::<Vec<_>>();
if !next_commits.contains(&main) {
warn!(
"Main branch '{}' is not on the same commit as next branch '{}', or it's parent - resetting next to main",
config.branches().main(),
config.branches().next()
);
reset_next_to_main(next, main, &repo_details, &config, &git);
revalidate_positions(addr).await;
return;
}
let Some(next) = next_commits.first().cloned() else {
warn!("No commits on next branch '{}'", config.branches().next());
revalidate_positions(addr).await;
return;
};
let dev_has_next = commit_histories
.dev
.iter()
.any(|commit| commit == &next_commits[0]);
if !dev_has_next {
warn!(
"Dev branch '{}' is not based on next branch '{}' - next branch will be updated shortly",
config.branches().dev(),
config.branches().next()
);
revalidate_positions(addr).await;
return; // dev is not based on next
}
let dev_has_main = commit_histories.dev.iter().any(|commit| commit == &main);
if !dev_has_main {
warn!(
"Dev branch '{}' is not based on main branch '{}' - user should rebase onto main branch '{}'",
config.branches().dev(),
config.branches().main(),
config.branches().main(),
);
revalidate_positions(addr).await;
return;
}
let Some(dev) = commit_histories.dev.first().cloned() else {
warn!("No commits on dev branch '{}'", config.branches().dev());
revalidate_positions(addr).await;
return;
};
addr.do_send(StartMonitoring {
main,
next,
dev,
dev_commit_history: commit_histories.dev,
});
}
async fn get_commit_histories(
repo_details: &RepoDetails,
config: &RepoConfig,
net: &Network,
) -> Result<CommitHistories, network::NetworkError> {
match repo_details.forge.forge_type {
#[cfg(feature = "forgejo")]
config::ForgeType::ForgeJo => {
forge::forgejo::get_commit_histories(repo_details, config, net).await
}
#[cfg(test)]
config::ForgeType::MockForge => {
forge::mock::get_commit_histories(repo_details, config, net).await
}
}
}
fn reset_next_to_main(
next: forge::Commit,
main: forge::Commit,
repo_details: &RepoDetails,
repo_config: &RepoConfig,
git: &Git,
) {
let reset = git.reset(
&repo_config.branches().next(),
main.into(),
ResetForce::Force(next.into()),
repo_details,
);
if let Err(err) = reset {
warn!(?err, "Failed");
}
}
async fn revalidate_positions(addr: Addr<RepoActor>) {
// TODO : (#43) sleep and restart while we don't have webhooks
tokio::time::sleep(std::time::Duration::from_secs(10)).await;
addr.do_send(ValidateRepo)
}
// advance next to the next commit towards the head of the dev branch
#[tracing::instrument(fields(next), skip_all)]
pub async fn advance_next(
next: forge::Commit,
dev_commit_history: Vec<forge::Commit>,
repo_details: config::RepoDetails,
repo_config: config::RepoConfig,
addr: Addr<RepoActor>,
git: Git,
) {
let next_commit = find_next_commit_on_dev(next, dev_commit_history);
let Some(commit) = next_commit else {
warn!("No commits to advance next to");
revalidate_positions(addr).await;
return;
};
if let Some(problem) = validate_commit_message(commit.message()) {
warn!("Can't advance next to commit '{}': {}", commit, problem);
revalidate_positions(addr).await;
return;
}
2024-04-12 17:41:09 +01:00
info!("Advancing next to commit '{}'", commit);
if let Err(err) = git.reset(
&repo_config.branches().next(),
commit.into(),
ResetForce::None,
&repo_details,
) {
warn!(?err, "Failed")
};
revalidate_positions(addr).await;
}
#[tracing::instrument]
fn validate_commit_message(message: &forge::Message) -> Option<String> {
let message = &message.to_string();
if message.to_ascii_lowercase().starts_with("wip") {
return Some("Is Work-In-Progress".to_string());
}
match git_conventional::Commit::parse(message) {
Ok(commit) => {
info!(?commit, "Pass");
None
}
Err(err) => {
warn!(?err, "Fail");
Some(err.kind().to_string())
}
}
}
fn find_next_commit_on_dev(
next: forge::Commit,
dev_commit_history: Vec<forge::Commit>,
) -> Option<forge::Commit> {
let mut next_commit: Option<forge::Commit> = None;
for commit in dev_commit_history.into_iter() {
if commit == next {
break;
};
next_commit.replace(commit);
}
next_commit
}
// advance main branch to the commit 'next'
#[tracing::instrument(fields(next), skip_all)]
pub async fn advance_main(
next: forge::Commit,
repo_details: config::RepoDetails,
repo_config: config::RepoConfig,
git: Git,
) {
2024-04-12 17:41:09 +01:00
info!("Advancing main to next");
2024-04-12 19:43:21 +01:00
if let Err(err) = git.reset(
&repo_config.branches().main(),
next.into(),
ResetForce::None,
&repo_details,
) {
2024-04-12 19:43:21 +01:00
warn!(?err, "Failed")
};
}
#[cfg(test)]
mod tests {
use super::*;
#[actix_rt::test]
async fn test_find_next_commit_on_dev() {
let next = forge::Commit::new("current-next", "foo");
let expected = forge::Commit::new("dev-next", "next-should-go-here");
let dev_commit_history = vec![
forge::Commit::new("dev", "future"),
expected.clone(),
next.clone(),
forge::Commit::new("current-main", "history"),
];
let next_commit = find_next_commit_on_dev(next, dev_commit_history);
assert_eq!(next_commit, Some(expected));
}
}