Tidy up and don't clone as much

Author: archessmn

src/check.rs

@@ -42,13 +42,13 @@ pub async fn start_status_checks(state: super::AppState) {
     loop {
         tokio::select! {
             _ = ticker.tick() => {
-                check_status(state.clone(), &http_client).await;
+                check_status(&state, &http_client).await;
             }
         }
     }
 }
 
-pub async fn check_status(state: super::AppState, client: &reqwest::Client) {
+pub async fn check_status(state: &super::AppState, client: &reqwest::Client) {
     let service_response = get_service_tags(&state).await;
 
     let is_active_service = is_active_service(&service_response).await;
@@ -66,7 +66,7 @@ pub async fn check_status(state: super::AppState, client: &reqwest::Client) {
         println!("Changing service state");
         match state
             .consul
-            .register_service(is_active_host, is_eligible_host)
+            .register_service(state, is_active_host, is_eligible_host)
             .await
         {
             Result::Ok(_) => println!("Success!"),
@@ -78,7 +78,7 @@ pub async fn check_status(state: super::AppState, client: &reqwest::Client) {
 pub async fn get_service_tags(state: &super::AppState) -> ServiceResponse {
     state
         .consul
-        .get_self()
+        .get_self(state)
         .await
         .unwrap_or(ServiceResponse { tags: Vec::new() })
 }

src/consul/client.rs

@@ -2,14 +2,13 @@ use hyper::http::StatusCode;
 use reqwest::{Method, RequestBuilder, Result};
 use serde::{Deserialize, Serialize};
 
-use crate::config::BalancerConfig;
+use crate::AppState;
 
 use super::config::Config;
 use super::service::{AgentServiceRegister, ServiceCheck};
 
 pub struct Consul {
     config: Config,
-    app_config: BalancerConfig,
     http_client: reqwest::Client,
 }
 
@@ -31,11 +30,10 @@ pub struct ServiceResponse {
 }
 
 impl Consul {
-    pub fn new(config: Config, app_config: BalancerConfig) -> Self {
+    pub fn new(config: Config) -> Self {
         let http_client = reqwest::Client::new();
         Self {
             config,
-            app_config,
             http_client,
         }
     }
@@ -66,9 +64,9 @@ impl Consul {
         Ok(res)
     }
 
-    pub async fn get_self(&self) -> Result<ServiceResponse> {
-        let hostname = &self.app_config.hostname;
-        let service_name = &self.app_config.consul.service_name;
+    pub async fn get_self(&self, state: &AppState) -> Result<ServiceResponse> {
+        let hostname = &state.app_config.hostname;
+        let service_name = &state.app_config.consul.service_name;
 
         let res = self
             .make_request(
@@ -82,9 +80,14 @@ impl Consul {
         Ok(res)
     }
 
-    pub async fn register_service(&self, active: bool, eligible: bool) -> Result<StatusCode> {
-        let hostname = &self.app_config.hostname;
-        let service_name = &self.app_config.consul.service_name;
+    pub async fn register_service(
+        &self,
+        state: &AppState,
+        active: bool,
+        eligible: bool,
+    ) -> Result<StatusCode> {
+        let hostname = &state.app_config.hostname;
+        let service_name = &state.app_config.consul.service_name;
 
         let mut tags: Vec<String> = Vec::from(["live".into()]);
 
@@ -100,8 +103,8 @@ impl Consul {
             tags.push("ineligible".into());
         }
 
-        let service_address = &self.app_config.consul.service_address;
-        let service_port = &self.app_config.http.port;
+        let service_address = &state.app_config.consul.service_address;
+        let service_port = &state.app_config.http.port;
 
         let http_check = ServiceCheck {
             http: format!("http://{service_address}:{service_port}/healthz").into(),
@@ -112,8 +115,8 @@ impl Consul {
         let service = AgentServiceRegister {
             name: service_name.into(),
             id: Some(format!("{service_name}/{hostname}").into()),
-            address: Some((&self.app_config.consul.service_address).into()),
-            port: Some(self.app_config.http.port),
+            address: Some((&state.app_config.consul.service_address).into()),
+            port: Some(state.app_config.http.port),
             tags,
             checks: Vec::from([http_check]),
         };

src/main.rs

@@ -37,15 +37,15 @@ async fn main() {
         address: app_config.consul.agent_url.clone(),
     };
 
-    let consul = Consul::new(consul_config, app_config.clone());
-
-    let _ = consul.register_service(false, false).await;
+    let consul = Consul::new(consul_config);
 
     let state = AppState {
         consul: Arc::new(consul),
         app_config: Arc::new(app_config),
     };
 
+    let _ = state.consul.register_service(&state, false, false).await;
+
     tokio::spawn(check::start_status_checks(state.clone()));
 
     // build our application with a single route
@@ -56,9 +56,11 @@ async fn main() {
         .route("/status", get(get_eligibility))
         .with_state(state.clone());
 
-    println!("> Starting HTTP server on port 3000");
+    let port = &state.app_config.http.port;
+
+    println!("> Starting HTTP server on port {port}");
     // run our app with hyper, listening globally on port 3000
-    let listener = util::get_http_server(state.clone()).await;
+    let listener = util::get_http_server(&state).await;
     axum::serve(listener, app).await.unwrap();
 }
 

src/util.rs

@@ -1,19 +1,17 @@
-use std::sync::Arc;
-
 use axum::Json;
 use hyper::StatusCode;
 use serde_json::json;
 
-use crate::{config::BalancerConfig, AppState};
+use crate::AppState;
 
-pub async fn get_http_server(state: AppState) -> tokio::net::TcpListener {
-    let listen_address = get_listen_host(state.app_config);
+pub async fn get_http_server(state: &AppState) -> tokio::net::TcpListener {
+    let listen_address = get_listen_host(state);
     return tokio::net::TcpListener::bind(listen_address).await.unwrap();
 }
 
-pub fn get_listen_host(config: Arc<BalancerConfig>) -> String {
-    let listen_address = &config.http.address;
-    let port = &config.http.port;
+pub fn get_listen_host(state: &AppState) -> String {
+    let listen_address = &state.app_config.http.address;
+    let port = &state.app_config.http.port;
     format!("{listen_address}:{port}")
 }