kemitix/git-next
1
1
Fork 1
Code Issues 18 Pull requests 1 Projects 1 Releases 41 Packages 2 Wiki Activity Actions

refactor: use Option<&T> over &Option<T>

Browse source
This commit is contained in:
Paul Campbell 2024-07-21 09:32:08 +01:00
parent d03ec7036d
commit a8d9b5536e
12 changed files with 72 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
crates/repo-actor/src/handlers/advance_main.rs
View file

@ -30,21 +30,18 @@ impl Handler<actor::messages::AdvanceMain> for actor::RepoActor {
Err(err) => { Err(err) => {
tracing::warn!("advance main: {err}"); tracing::warn!("advance main: {err}");
} }
Ok(_) => { Ok(_) => match repo_config.source() {
let log = self.log.clone();
match repo_config.source() {
git_next_config::RepoConfigSource::Repo => { git_next_config::RepoConfigSource::Repo => {
actor::do_send(addr, actor::messages::LoadConfigFromRepo, &log); actor::do_send(addr, actor::messages::LoadConfigFromRepo, self.log.as_ref());
} }
git_next_config::RepoConfigSource::Server => { git_next_config::RepoConfigSource::Server => {
actor::do_send( actor::do_send(
addr, addr,
actor::messages::ValidateRepo::new(message_token), actor::messages::ValidateRepo::new(message_token),
&log, self.log.as_ref(),
); );
} }
} },
}
} }
} }
} }

2
crates/repo-actor/src/handlers/advance_next.rs
View file

@ -35,7 +35,7 @@ impl Handler<actor::messages::AdvanceNext> for actor::RepoActor {
actor::do_send( actor::do_send(
addr, addr,
actor::messages::ValidateRepo::new(message_token), actor::messages::ValidateRepo::new(message_token),
&self.log, self.log.as_ref(),
); );
} }
Err(err) => tracing::warn!("advance next: {err}"), Err(err) => tracing::warn!("advance next: {err}"),

4
crates/repo-actor/src/handlers/check_ci_status.rs
View file

@ -11,7 +11,7 @@ impl Handler<actor::messages::CheckCIStatus> for actor::RepoActor {
msg: actor::messages::CheckCIStatus, msg: actor::messages::CheckCIStatus,
ctx: &mut Self::Context, ctx: &mut Self::Context,
) -> Self::Result { ) -> Self::Result {
actor::logger(&self.log, "start: CheckCIStatus"); actor::logger(self.log.as_ref(), "start: CheckCIStatus");
let addr = ctx.address(); let addr = ctx.address();
let forge = self.forge.duplicate(); let forge = self.forge.duplicate();
let next = msg.unwrap(); let next = msg.unwrap();
@ -24,7 +24,7 @@ impl Handler<actor::messages::CheckCIStatus> for actor::RepoActor {
actor::do_send( actor::do_send(
addr, addr,
actor::messages::ReceiveCIStatus::new((next, status)), actor::messages::ReceiveCIStatus::new((next, status)),
&log, log.as_ref(),
); );
} }
.in_current_span() .in_current_span()

10
crates/repo-actor/src/handlers/clone_repo.rs
View file

@ -12,29 +12,29 @@ impl Handler<actor::messages::CloneRepo> for actor::RepoActor {
_msg: actor::messages::CloneRepo, _msg: actor::messages::CloneRepo,
ctx: &mut Self::Context, ctx: &mut Self::Context,
) -> Self::Result { ) -> Self::Result {
actor::logger(&self.log, "Handler: CloneRepo: start"); actor::logger(self.log.as_ref(), "Handler: CloneRepo: start");
tracing::debug!("Handler: CloneRepo: start"); tracing::debug!("Handler: CloneRepo: start");
match git::repository::open(&*self.repository_factory, &self.repo_details) { match git::repository::open(&*self.repository_factory, &self.repo_details) {
Ok(repository) => { Ok(repository) => {
actor::logger(&self.log, "open okay"); actor::logger(self.log.as_ref(), "open okay");
tracing::debug!("open okay"); tracing::debug!("open okay");
self.open_repository.replace(repository); self.open_repository.replace(repository);
if self.repo_details.repo_config.is_none() { if self.repo_details.repo_config.is_none() {
actor::do_send( actor::do_send(
ctx.address(), ctx.address(),
actor::messages::LoadConfigFromRepo, actor::messages::LoadConfigFromRepo,
&self.log, self.log.as_ref(),
); );
} else { } else {
actor::do_send( actor::do_send(
ctx.address(), ctx.address(),
actor::messages::RegisterWebhook::new(), actor::messages::RegisterWebhook::new(),
&self.log, self.log.as_ref(),
); );
} }
} }
Err(err) => { Err(err) => {
actor::logger(&self.log, "open failed"); actor::logger(self.log.as_ref(), "open failed");
tracing::debug!("err: {err:?}"); tracing::debug!("err: {err:?}");
tracing::warn!("Could not open repo: {err}") tracing::warn!("Could not open repo: {err}")
} }

2
crates/repo-actor/src/handlers/load_config_from_repo.rs
View file

@ -23,7 +23,7 @@ impl Handler<actor::messages::LoadConfigFromRepo> for actor::RepoActor {
async move { async move {
match actor::load::config_from_repository(repo_details, &*open_repository).await { match actor::load::config_from_repository(repo_details, &*open_repository).await {
Ok(repo_config) => { Ok(repo_config) => {
actor::logger(&log, "send: LoadedConfig"); actor::logger(log.as_ref(), "send: LoadedConfig");
addr.do_send(actor::messages::ReceiveRepoConfig::new(repo_config)) addr.do_send(actor::messages::ReceiveRepoConfig::new(repo_config))
} }
Err(err) => { Err(err) => {

12
crates/repo-actor/src/handlers/receive_ci_status.rs
View file

@ -12,7 +12,7 @@ impl Handler<actor::messages::ReceiveCIStatus> for actor::RepoActor {
ctx: &mut Self::Context, ctx: &mut Self::Context,
) -> Self::Result { ) -> Self::Result {
let log = self.log.clone(); let log = self.log.clone();
actor::logger(&log, "start: ReceiveCIStatus"); actor::logger(log.as_ref(), "start: ReceiveCIStatus");
let addr = ctx.address(); let addr = ctx.address();
let (next, status) = msg.unwrap(); let (next, status) = msg.unwrap();
let message_token = self.message_token; let message_token = self.message_token;
@ -21,14 +21,18 @@ impl Handler<actor::messages::ReceiveCIStatus> for actor::RepoActor {
tracing::debug!(?status, ""); tracing::debug!(?status, "");
match status { match status {
git::forge::commit::Status::Pass => { git::forge::commit::Status::Pass => {
actor::do_send(addr, actor::messages::AdvanceMain::new(next), &self.log); actor::do_send(
addr,
actor::messages::AdvanceMain::new(next),
self.log.as_ref(),
);
} }
git::forge::commit::Status::Pending => { git::forge::commit::Status::Pending => {
std::thread::sleep(sleep_duration); std::thread::sleep(sleep_duration);
actor::do_send( actor::do_send(
addr, addr,
actor::messages::ValidateRepo::new(message_token), actor::messages::ValidateRepo::new(message_token),
&self.log, self.log.as_ref(),
); );
} }
git::forge::commit::Status::Fail => { git::forge::commit::Status::Fail => {
@ -38,7 +42,7 @@ impl Handler<actor::messages::ReceiveCIStatus> for actor::RepoActor {
addr, addr,
sleep_duration, sleep_duration,
actor::messages::ValidateRepo::new(message_token), actor::messages::ValidateRepo::new(message_token),
&self.log, self.log.as_ref(),
); );
} }
} }

2
crates/repo-actor/src/handlers/receive_repo_config.rs
View file

@ -17,7 +17,7 @@ impl Handler<actor::messages::ReceiveRepoConfig> for actor::RepoActor {
actor::do_send( actor::do_send(
ctx.address(), ctx.address(),
actor::messages::RegisterWebhook::new(), actor::messages::RegisterWebhook::new(),
&self.log, self.log.as_ref(),
); );
} }
} }

4
crates/repo-actor/src/handlers/register_webhook.rs
View file

@ -25,7 +25,7 @@ impl Handler<RegisterWebhook> for RepoActor {
actor::do_send( actor::do_send(
addr, addr,
actor::messages::WebhookRegistered::from(registered_webhook), actor::messages::WebhookRegistered::from(registered_webhook),
&log, log.as_ref(),
); );
} }
Err(err) => { Err(err) => {
@ -36,7 +36,7 @@ impl Handler<RegisterWebhook> for RepoActor {
)); ));
let log_message = format!("send: {:?}", msg); let log_message = format!("send: {:?}", msg);
tracing::debug!(log_message); tracing::debug!(log_message);
actor::logger(&log, log_message); actor::logger(log.as_ref(), log_message);
if let Some(notify_user_recipient) = notify_user_recipient { if let Some(notify_user_recipient) = notify_user_recipient {
notify_user_recipient.do_send(msg); notify_user_recipient.do_send(msg);
} }

33
crates/repo-actor/src/handlers/validate_repo.rs
View file

@ -14,14 +14,14 @@ impl Handler<actor::messages::ValidateRepo> for actor::RepoActor {
msg: actor::messages::ValidateRepo, msg: actor::messages::ValidateRepo,
ctx: &mut Self::Context, ctx: &mut Self::Context,
) -> Self::Result { ) -> Self::Result {
actor::logger(&self.log, "start: ValidateRepo"); actor::logger(self.log.as_ref(), "start: ValidateRepo");
// Message Token - make sure we are only triggered for the latest/current token // Message Token - make sure we are only triggered for the latest/current token
match self.token_status(msg.unwrap()) { match self.token_status(msg.unwrap()) {
TokenStatus::Current => {} // do nothing TokenStatus::Current => {} // do nothing
TokenStatus::Expired => { TokenStatus::Expired => {
actor::logger( actor::logger(
&self.log, self.log.as_ref(),
format!("discarded: old message token: {}", self.message_token), format!("discarded: old message token: {}", self.message_token),
); );
return; // message is expired return; // message is expired
@ -29,24 +29,27 @@ impl Handler<actor::messages::ValidateRepo> for actor::RepoActor {
TokenStatus::New(message_token) => { TokenStatus::New(message_token) => {
self.message_token = message_token; self.message_token = message_token;
actor::logger( actor::logger(
&self.log, self.log.as_ref(),
format!("new message token: {}", self.message_token), format!("new message token: {}", self.message_token),
); );
} }
} }
actor::logger(&self.log, format!("accepted token: {}", self.message_token)); actor::logger(
self.log.as_ref(),
format!("accepted token: {}", self.message_token),
);
// Repository positions // Repository positions
let Some(ref open_repository) = self.open_repository else { let Some(ref open_repository) = self.open_repository else {
actor::logger(&self.log, "no open repository"); actor::logger(self.log.as_ref(), "no open repository");
return; return;
}; };
actor::logger(&self.log, "have open repository"); actor::logger(self.log.as_ref(), "have open repository");
let Some(repo_config) = self.repo_details.repo_config.clone() else { let Some(repo_config) = self.repo_details.repo_config.clone() else {
actor::logger(&self.log, "no repo config"); actor::logger(self.log.as_ref(), "no repo config");
return; return;
}; };
actor::logger(&self.log, "have repo config"); actor::logger(self.log.as_ref(), "have repo config");
match git::validation::positions::validate_positions( match git::validation::positions::validate_positions(
&**open_repository, &**open_repository,
@ -64,33 +67,33 @@ impl Handler<actor::messages::ValidateRepo> for actor::RepoActor {
actor::do_send( actor::do_send(
ctx.address(), ctx.address(),
actor::messages::CheckCIStatus::new(next), actor::messages::CheckCIStatus::new(next),
&self.log, self.log.as_ref(),
); );
} else if next != dev { } else if next != dev {
actor::do_send( actor::do_send(
ctx.address(), ctx.address(),
actor::messages::AdvanceNext::new((next, dev_commit_history)), actor::messages::AdvanceNext::new((next, dev_commit_history)),
&self.log, self.log.as_ref(),
) )
} else { } else {
// do nothing // do nothing
} }
} }
Err(git::validation::positions::Error::Retryable(message)) => { Err(git::validation::positions::Error::Retryable(message)) => {
actor::logger(&self.log, message); actor::logger(self.log.as_ref(), message);
let addr = ctx.address(); let addr = ctx.address();
let message_token = self.message_token; let message_token = self.message_token;
let sleep_duration = self.sleep_duration; let sleep_duration = self.sleep_duration;
let log = self.log.clone(); let log = self.log.clone();
async move { async move {
tracing::debug!("sleeping before retrying..."); tracing::debug!("sleeping before retrying...");
actor::logger(&log, "before sleep"); actor::logger(log.as_ref(), "before sleep");
tokio::time::sleep(sleep_duration).await; tokio::time::sleep(sleep_duration).await;
actor::logger(&log, "after sleep"); actor::logger(log.as_ref(), "after sleep");
actor::do_send( actor::do_send(
addr, addr,
actor::messages::ValidateRepo::new(message_token), actor::messages::ValidateRepo::new(message_token),
&log, log.as_ref(),
); );
} }
.in_current_span() .in_current_span()
@ -99,7 +102,7 @@ impl Handler<actor::messages::ValidateRepo> for actor::RepoActor {
} }
Err(git::validation::positions::Error::NonRetryable(message)) Err(git::validation::positions::Error::NonRetryable(message))
| Err(git::validation::positions::Error::UserIntervention(message)) => { | Err(git::validation::positions::Error::UserIntervention(message)) => {
actor::logger(&self.log, message); actor::logger(self.log.as_ref(), message);
} }
} }

29
crates/repo-actor/src/handlers/webhook_notification.rs
View file

@ -17,23 +17,30 @@ impl Handler<WebhookNotification> for actor::RepoActor {
#[tracing::instrument(name = "RepoActor::WebhookMessage", skip_all, fields(token = %self.message_token, repo = %self.repo_details))] #[tracing::instrument(name = "RepoActor::WebhookMessage", skip_all, fields(token = %self.message_token, repo = %self.repo_details))]
fn handle(&mut self, msg: WebhookNotification, ctx: &mut Self::Context) -> Self::Result { fn handle(&mut self, msg: WebhookNotification, ctx: &mut Self::Context) -> Self::Result {
let Some(config) = &self.repo_details.repo_config else { let Some(config) = &self.repo_details.repo_config else {
actor::logger(&self.log, "server has no repo config"); actor::logger(self.log.as_ref(), "server has no repo config");
warn!("No repo config"); warn!("No repo config");
return; return;
}; };
if validate_notification(&msg, &self.webhook_auth, &*self.forge, &self.log).is_err() { if validate_notification(
&msg,
self.webhook_auth.as_ref(),
&*self.forge,
self.log.as_ref(),
)
.is_err()
{
return; return;
} }
let body = msg.body(); let body = msg.body();
match self.forge.parse_webhook_body(body) { match self.forge.parse_webhook_body(body) {
Err(err) => { Err(err) => {
actor::logger(&self.log, "message parse error - not a push"); actor::logger(self.log.as_ref(), "message parse error - not a push");
warn!(?err, "Not a 'push'"); warn!(?err, "Not a 'push'");
return; return;
} }
Ok(push) => match push.branch(config.branches()) { Ok(push) => match push.branch(config.branches()) {
None => { None => {
actor::logger(&self.log, "unknown branch"); actor::logger(self.log.as_ref(), "unknown branch");
warn!( warn!(
?push, ?push,
"Unrecognised branch, we should be filtering to only the ones we want" "Unrecognised branch, we should be filtering to only the ones we want"
@ -45,7 +52,7 @@ impl Handler<WebhookNotification> for actor::RepoActor {
push, push,
config.branches().main(), config.branches().main(),
&mut self.last_main_commit, &mut self.last_main_commit,
&self.log, self.log.as_ref(),
) )
.is_err() .is_err()
{ {
@ -57,7 +64,7 @@ impl Handler<WebhookNotification> for actor::RepoActor {
push, push,
config.branches().next(), config.branches().next(),
&mut self.last_next_commit, &mut self.last_next_commit,
&self.log, self.log.as_ref(),
) )
.is_err() .is_err()
{ {
@ -69,7 +76,7 @@ impl Handler<WebhookNotification> for actor::RepoActor {
push, push,
config.branches().dev(), config.branches().dev(),
&mut self.last_dev_commit, &mut self.last_dev_commit,
&self.log, self.log.as_ref(),
) )
.is_err() .is_err()
{ {
@ -86,16 +93,16 @@ impl Handler<WebhookNotification> for actor::RepoActor {
actor::do_send( actor::do_send(
ctx.address(), ctx.address(),
actor::messages::ValidateRepo::new(message_token), actor::messages::ValidateRepo::new(message_token),
&self.log, self.log.as_ref(),
); );
} }
} }
fn validate_notification( fn validate_notification(
msg: &WebhookNotification, msg: &WebhookNotification,
webhook_auth: &Option<WebhookAuth>, webhook_auth: Option<&WebhookAuth>,
forge: &dyn ForgeLike, forge: &dyn ForgeLike,
log: &Option<RepoActorLog>, log: Option<&RepoActorLog>,
) -> Result<(), ()> { ) -> Result<(), ()> {
let Some(expected_authorization) = webhook_auth else { let Some(expected_authorization) = webhook_auth else {
actor::logger(log, "server has no auth token"); actor::logger(log, "server has no auth token");
@ -122,7 +129,7 @@ fn handle_push(
push: Push, push: Push,
branch: BranchName, branch: BranchName,
last_commit: &mut Option<Commit>, last_commit: &mut Option<Commit>,
log: &Option<RepoActorLog>, log: Option<&RepoActorLog>,
) -> Result<(), ()> { ) -> Result<(), ()> {
actor::logger(log, "message is for dev branch"); actor::logger(log, "message is for dev branch");
let commit = git::Commit::from(push); let commit = git::Commit::from(push);

2
crates/repo-actor/src/handlers/webhook_registered.rs
View file

@ -16,7 +16,7 @@ impl Handler<actor::messages::WebhookRegistered> for actor::RepoActor {
actor::do_send( actor::do_send(
ctx.address(), ctx.address(),
actor::messages::ValidateRepo::new(self.message_token), actor::messages::ValidateRepo::new(self.message_token),
&self.log, self.log.as_ref(),
); );
} }
} }

12
crates/repo-actor/src/lib.rs
View file

@ -118,12 +118,8 @@ impl Actor for RepoActor {
} }
} }
pub fn delay_send<M>( pub fn delay_send<M>(addr: Addr<RepoActor>, delay: Duration, msg: M, log: Option<&RepoActorLog>)
addr: Addr<RepoActor>, where
delay: Duration,
msg: M,
log: &Option<crate::RepoActorLog>,
) where
M: actix::Message + Send + 'static + std::fmt::Debug, M: actix::Message + Send + 'static + std::fmt::Debug,
RepoActor: actix::Handler<M>, RepoActor: actix::Handler<M>,
<M as actix::Message>::Result: Send, <M as actix::Message>::Result: Send,
@ -135,7 +131,7 @@ pub fn delay_send<M>(
do_send(addr, msg, log) do_send(addr, msg, log)
} }
pub fn do_send<M>(_addr: Addr<RepoActor>, msg: M, log: &Option<crate::RepoActorLog>) pub fn do_send<M>(_addr: Addr<RepoActor>, msg: M, log: Option<&RepoActorLog>)
where where
M: actix::Message + Send + 'static + std::fmt::Debug, M: actix::Message + Send + 'static + std::fmt::Debug,
RepoActor: actix::Handler<M>, RepoActor: actix::Handler<M>,
@ -148,7 +144,7 @@ where
_addr.do_send(msg) _addr.do_send(msg)
} }
pub fn logger(log: &Option<crate::RepoActorLog>, message: impl Into<String>) { pub fn logger(log: Option<&RepoActorLog>, message: impl Into<String>) {
if let Some(log) = log { if let Some(log) = log {
let message: String = message.into(); let message: String = message.into();
tracing::debug!(message); tracing::debug!(message);