139 lines
4.2 KiB
Rust
139 lines
4.2 KiB
Rust
mod branch;
|
|
mod config;
|
|
pub mod status;
|
|
mod webhook;
|
|
|
|
use actix::prelude::*;
|
|
use kxio::network::Network;
|
|
use tracing::info;
|
|
|
|
use crate::server::{
|
|
config::{RepoConfig, RepoDetails},
|
|
forge,
|
|
};
|
|
|
|
use self::webhook::WebhookId;
|
|
|
|
pub struct RepoActor {
|
|
details: RepoDetails,
|
|
config: Option<RepoConfig>, // INFO: if [None] then send [StartRepo] to populate it
|
|
webhook_id: Option<WebhookId>, // INFO: if [None] then no webhook is configured
|
|
net: Network,
|
|
}
|
|
impl RepoActor {
|
|
pub(crate) const fn new(details: RepoDetails, net: Network) -> Self {
|
|
Self {
|
|
details,
|
|
config: None,
|
|
webhook_id: None,
|
|
net,
|
|
}
|
|
}
|
|
}
|
|
impl Actor for RepoActor {
|
|
type Context = Context<Self>;
|
|
fn stopping(&mut self, ctx: &mut Self::Context) -> Running {
|
|
match self.webhook_id.take() {
|
|
Some(webhook_id) => {
|
|
let repo_details = self.details.clone();
|
|
let addr = ctx.address();
|
|
let net = self.net.clone();
|
|
webhook::unregister(webhook_id, repo_details, addr, net)
|
|
.into_actor(self)
|
|
.wait(ctx);
|
|
Running::Continue
|
|
}
|
|
None => Running::Stop,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Message)]
|
|
#[rtype(result = "()")]
|
|
pub struct StartRepo;
|
|
impl Handler<StartRepo> for RepoActor {
|
|
type Result = ();
|
|
fn handle(&mut self, _msg: StartRepo, ctx: &mut Self::Context) -> Self::Result {
|
|
info!(%self.details, "Starting Repo");
|
|
let details = self.details.clone();
|
|
let addr = ctx.address();
|
|
let net = self.net.clone();
|
|
config::load(details, addr, net).into_actor(self).wait(ctx);
|
|
}
|
|
}
|
|
|
|
#[derive(Message)]
|
|
#[rtype(result = "()")]
|
|
struct LoadedConfig(pub RepoConfig);
|
|
impl Handler<LoadedConfig> for RepoActor {
|
|
type Result = ();
|
|
fn handle(&mut self, msg: LoadedConfig, ctx: &mut Self::Context) -> Self::Result {
|
|
let config = msg.0;
|
|
info!(%self.details, %config, "Config loaded");
|
|
self.config.replace(config.clone());
|
|
let repo_details = self.details.clone();
|
|
let addr = ctx.address();
|
|
let net = self.net.clone();
|
|
branch::validate_positions(repo_details, config, addr, net)
|
|
.into_actor(self)
|
|
.wait(ctx);
|
|
}
|
|
}
|
|
|
|
#[derive(Message)]
|
|
#[rtype(result = "()")]
|
|
pub struct StartMonitoring {
|
|
pub main: forge::Commit,
|
|
pub next: forge::Commit,
|
|
pub dev: forge::Commit,
|
|
}
|
|
impl Handler<StartMonitoring> for RepoActor {
|
|
type Result = ();
|
|
fn handle(&mut self, msg: StartMonitoring, ctx: &mut Self::Context) -> Self::Result {
|
|
info!("Monitoring started");
|
|
let next_ahead_of_main = msg.main != msg.next;
|
|
let dev_ahead_of_next = msg.next != msg.dev;
|
|
let repo_details = self.details.clone();
|
|
let addr = ctx.address();
|
|
let net = self.net.clone();
|
|
if next_ahead_of_main {
|
|
status::check_next(msg.next, repo_details, addr, net)
|
|
.into_actor(self)
|
|
.wait(ctx);
|
|
} else if dev_ahead_of_next {
|
|
branch::advance_next(msg.next, repo_details, addr, net)
|
|
.into_actor(self)
|
|
.wait(ctx);
|
|
} else if self.webhook_id.is_none() {
|
|
webhook::register(repo_details, addr, net)
|
|
.into_actor(self)
|
|
.wait(ctx)
|
|
// TODO: (#18) watch for changes on dev
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Message)]
|
|
#[rtype(result = "()")]
|
|
pub struct WebhookRegistered(pub WebhookId);
|
|
impl Handler<WebhookRegistered> for RepoActor {
|
|
type Result = ();
|
|
fn handle(&mut self, msg: WebhookRegistered, _ctx: &mut Self::Context) -> Self::Result {
|
|
self.webhook_id.replace(msg.0);
|
|
}
|
|
}
|
|
|
|
#[derive(Message)]
|
|
#[rtype(result = "()")]
|
|
pub struct AdvanceMainTo(pub forge::Commit);
|
|
impl Handler<AdvanceMainTo> for RepoActor {
|
|
type Result = ();
|
|
fn handle(&mut self, msg: AdvanceMainTo, ctx: &mut Self::Context) -> Self::Result {
|
|
let repo_details = self.details.clone();
|
|
let addr = ctx.address();
|
|
let net = self.net.clone();
|
|
branch::advance_main(msg.0, repo_details, addr, net)
|
|
.into_actor(self)
|
|
.wait(ctx);
|
|
}
|
|
}
|