Clear bad clone() and String::from()

EliXorZz · EliXorZz · commit a3fa59f12061 · 2022-07-28T16:38:24.000+02:00
diff --git a/src/controller/definitions/epsilon_instance.rs b/src/controller/definitions/epsilon_instance.rs
@@ -5,7 +5,6 @@ use crate::epsilon::server::instances::common::instance_type::InstanceType;
 use crate::epsilon::server::instances::common::state::EpsilonState;
 
 use crate::epsilon::epsilon_error::EpsilonError;
-use anyhow::format_err;
 use async_minecraft_ping::{ConnectionConfig, StatusResponse};
 use kube::CustomResource;
 use schemars::JsonSchema;
@@ -50,7 +49,7 @@ impl EpsilonInstance {
         Ok(InstanceJson {
             name: self.get_name(),
             template: self.spec.template.clone(),
-            state: *self.get_state(),
+            state: self.get_state(),
 
             slots: self
                 .status
@@ -66,10 +65,10 @@ impl EpsilonInstance {
         self.metadata.name.as_ref().unwrap().to_owned()
     }
 
-    pub fn get_state(&self) -> &EpsilonState {
+    pub fn get_state(&self) -> EpsilonState {
         match &self.status {
-            None => &EpsilonState::Starting,
-            Some(status) => &status.state,
+            None => EpsilonState::Starting,
+            Some(status) => status.state,
         }
     }
 
diff --git a/src/controller/epsilon_controller.rs b/src/controller/epsilon_controller.rs
@@ -5,8 +5,7 @@ use crate::controller::definitions::epsilon_instance::{
 use crate::controller::definitions::epsilon_queue::EpsilonQueue;
 use crate::epsilon::epsilon_error::EpsilonError;
 use crate::epsilon::server::instances::common::state::EpsilonState;
-use crate::{EResult, TemplateProvider};
-use anyhow::format_err;
+use crate::TemplateProvider;
 use futures::stream::StreamExt;
 use k8s_openapi::api::core::v1::{
     ConfigMapEnvSource, Container, EnvFromSource, ExecAction, Pod, PodSpec, Probe,
@@ -19,6 +18,7 @@ use kube::runtime::Controller;
 use kube::{Api, Client, Config};
 use kube::{Error, Resource};
 use serde_json::json;
+use std::borrow::BorrowMut;
 use std::collections::BTreeMap;
 use std::env;
 use std::sync::Arc;
@@ -83,14 +83,13 @@ impl EpsilonController {
         let mut instance_owner_reference = epsilon_instance.controller_owner_ref(&()).unwrap();
         instance_owner_reference.block_owner_deletion = Some(true);
 
-        let instance_metadata = &epsilon_instance.metadata;
         let instance_spec = &epsilon_instance.spec;
         let instance_status = epsilon_instance.status.clone();
 
-        let instance_name = instance_metadata.name.as_ref().unwrap();
+        let instance_name = epsilon_instance.get_name();
         let template_name = &instance_spec.template;
 
-        if let Ok(pod_option) = pod_api.get_opt(instance_name).await {
+        if let Ok(pod_option) = pod_api.get_opt(&instance_name).await {
             match pod_option {
                 None => {
                     let template = template_provider.get_template(template_name).await.unwrap();
@@ -106,7 +105,7 @@ impl EpsilonController {
 
                     let pod = Pod {
                         metadata: ObjectMeta {
-                            name: Some(instance_name.clone()),
+                            name: Some(instance_name),
                             owner_references: Some(vec![instance_owner_reference]),
                             labels: Some(labels),
                             ..Default::default()
@@ -164,7 +163,7 @@ impl EpsilonController {
                 Some(pod) => {
                     let pod_status = pod.status.as_ref().unwrap();
 
-                    let pod_ip = pod_status.pod_ip.as_ref();
+                    let pod_ip = pod_status.pod_ip.as_ref().cloned();
 
                     if let Some(pod_conditions) = pod_status.conditions.as_ref() {
                         let pod_phase = pod_status.phase.as_ref().unwrap();
@@ -191,13 +190,13 @@ impl EpsilonController {
                                 let template =
                                     template_provider.get_template(template_name).await.unwrap();
 
-                                let instance_type = &template.t;
+                                let template_type = template.t.clone();
 
                                 EpsilonInstanceStatus {
-                                    ip: pod_ip.cloned(),
+                                    ip: pod_ip,
 
-                                    template: String::from(template_name),
-                                    t: instance_type.clone(),
+                                    template: template_name.to_owned(),
+                                    t: template_type,
 
                                     hub: template_provider.is_hub(&template),
 
@@ -211,7 +210,7 @@ impl EpsilonController {
                                 }
                             }
                             Some(mut status) => {
-                                status.ip = pod_ip.cloned();
+                                status.ip = pod_ip;
                                 status.state = state;
 
                                 status
@@ -220,7 +219,7 @@ impl EpsilonController {
 
                         epsilon_instance_api
                             .patch_status(
-                                instance_name,
+                                &instance_name,
                                 &PatchParams::default(),
                                 &Patch::Merge(json!({ "status": new_status })),
                             )
@@ -234,14 +233,14 @@ impl EpsilonController {
 
                             epsilon_instance_api
                                 .patch_status(
-                                    instance_name,
+                                    &instance_name,
                                     &PatchParams::default(),
                                     &Patch::Merge(json!({ "status": new_status })),
                                 )
                                 .await?;
 
                             epsilon_instance_api
-                                .delete(instance_name, &DeleteParams::default())
+                                .delete(&instance_name, &DeleteParams::default())
                                 .await?;
                         }
                     }
@@ -277,15 +276,15 @@ impl EpsilonController {
                 ..Default::default()
             },
             spec: EpsilonInstanceSpec {
-                template: String::from(template_name),
+                template: template_name.to_owned(),
             },
             status: None,
         };
 
         let instance_result = epsilon_instance_api
             .create(&PostParams::default(), &epsilon_instance)
             .await
-            .map_err(|_| EpsilonError::CreateInstanceError(String::from(template_name)));
+            .map_err(|_| EpsilonError::CreateInstanceError(template_name.to_owned()));
 
         Ok(instance_result?)
     }
@@ -310,14 +309,14 @@ impl EpsilonController {
                     &Patch::Merge(json!({ "status": instance_status })),
                 )
                 .await
-                .map_err(|_| EpsilonError::RemoveInstanceError(String::from(instance_name)))?;
+                .map_err(|_| EpsilonError::RemoveInstanceError(instance_name.to_owned()))?;
         }
 
         Ok(())
     }
 
-    pub fn get_epsilon_instance_api(&self) -> &Api<EpsilonInstance> {
-        &self.context.epsilon_instance_api
+    pub fn get_epsilon_instance_api(&self) -> Api<EpsilonInstance> {
+        self.context.epsilon_instance_api.clone()
     }
 
     pub fn get_epsilon_instance_store(&self) -> &Store<EpsilonInstance> {
diff --git a/src/epsilon/api/common/epsilon_events.rs b/src/epsilon/api/common/epsilon_events.rs
@@ -7,8 +7,9 @@ pub enum EpsilonEvent {
 
 impl ToString for EpsilonEvent {
     fn to_string(&self) -> String {
-        String::from(match self {
+        match self {
             EpsilonEvent::SendToServer(_, _) => "SendToServer",
-        })
+        }
+        .to_owned()
     }
 }
diff --git a/src/epsilon/epsilon_error.rs b/src/epsilon/epsilon_error.rs
@@ -1,5 +1,4 @@
 use rocket::http::Status;
-use rocket::http::StatusClass::ServerError;
 use rocket::response::Responder;
 use rocket::{response, Request, Response};
 use thiserror::Error;
@@ -35,7 +34,7 @@ pub enum EpsilonError {
 }
 
 impl<'r> Responder<'r, 'static> for EpsilonError {
-    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
+    fn respond_to(self, _req: &'r Request<'_>) -> response::Result<'static> {
         Response::build().status(Status::InternalServerError).ok()
     }
 }
diff --git a/src/epsilon/queue/queue_provider.rs b/src/epsilon/queue/queue_provider.rs
@@ -19,7 +19,7 @@ impl QueueProvider {
         let mut map = HashMap::new();
 
         for template in template_provider.get_templates().await? {
-            map.insert(String::from(&template.name), RwLock::new(Queue::new()));
+            map.insert(template.name.to_owned(), RwLock::new(Queue::new()));
         }
 
         Ok(QueueProvider { queue_map: map })
diff --git a/src/epsilon/server/instances/common/instance_type.rs b/src/epsilon/server/instances/common/instance_type.rs
@@ -42,7 +42,7 @@ impl FromStr for InstanceType {
     type Err = io::Error;
 
     fn from_str(input: &str) -> Result<InstanceType, Self::Err> {
-        match String::from(input).to_lowercase().as_str() {
+        match input.to_lowercase().as_str() {
             "server" => Ok(InstanceType::Server),
             "proxy" => Ok(InstanceType::Proxy),
             _ => Err(io::Error::new(
@@ -55,9 +55,10 @@ impl FromStr for InstanceType {
 
 impl ToString for InstanceType {
     fn to_string(&self) -> String {
-        String::from(match self {
+        match self {
             InstanceType::Server => "server",
             InstanceType::Proxy => "proxy",
-        })
+        }
+        .to_owned()
     }
 }
diff --git a/src/epsilon/server/instances/instance_provider.rs b/src/epsilon/server/instances/instance_provider.rs
@@ -1,4 +1,3 @@
-use futures::TryFutureExt;
 use std::sync::Arc;
 
 use kube::api::DeleteParams;
@@ -38,7 +37,7 @@ impl InstanceProvider {
             .get_epsilon_instance_api()
             .delete(name, &DeleteParams::default())
             .await
-            .map_err(|_| EpsilonError::RemoveInstanceError(String::from(name)))?;
+            .map_err(|_| EpsilonError::RemoveInstanceError(name.to_owned()))?;
 
         Ok(())
     }
@@ -64,7 +63,7 @@ impl InstanceProvider {
             let name = instance.get_name();
 
             let condition = await_condition(
-                self.epsilon_controller.get_epsilon_instance_api().clone(),
+                self.epsilon_controller.get_epsilon_instance_api(),
                 &name,
                 move |object: Option<&EpsilonInstance>| {
                     object.map_or(false, |instance| instance.status.is_some())
diff --git a/src/epsilon/server/templates/template_provider.rs b/src/epsilon/server/templates/template_provider.rs
@@ -1,8 +1,6 @@
 use std::env;
 use std::sync::Arc;
 
-use anyhow::format_err;
-
 use crate::epsilon::epsilon_error::EpsilonError;
 use crate::epsilon::server::templates::template::Template;
 use crate::EpsilonConfig;
diff --git a/src/tasks/queue_task.rs b/src/tasks/queue_task.rs
@@ -64,10 +64,7 @@ impl Task for QueueTask {
                                 if group_size <= available_slots {
                                     available_slots -= group_size;
 
-                                    epsilon_api.send(SendToServer(
-                                        group,
-                                        instance.metadata.name.as_ref().unwrap().clone(),
-                                    ));
+                                    epsilon_api.send(SendToServer(group, instance.get_name()));
                                 }
                             }
                         }

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,9 @@ pub enum EpsilonEvent {`
`7`	`7`
`8`	`8`	`impl ToString for EpsilonEvent {`
`9`	`9`	`fn to_string(&self) -> String {`
`10`		`- String::from(match self {`
	`10`	`+ match self {`
`11`	`11`	`EpsilonEvent::SendToServer(_, _) => "SendToServer",`
`12`		`- })`
	`12`	`+ }`
	`13`	`+ .to_owned()`
`13`	`14`	`}`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`use rocket::http::Status;`
`2`		`-use rocket::http::StatusClass::ServerError;`
`3`	`2`	`use rocket::response::Responder;`
`4`	`3`	`use rocket::{response, Request, Response};`
`5`	`4`	`use thiserror::Error;`
`@@ -35,7 +34,7 @@ pub enum EpsilonError {`
`35`	`34`	`}`
`36`	`35`
`37`	`36`	`impl<'r> Responder<'r, 'static> for EpsilonError {`
`38`		`- fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {`
	`37`	`+ fn respond_to(self, _req: &'r Request<'_>) -> response::Result<'static> {`
`39`	`38`	`Response::build().status(Status::InternalServerError).ok()`
`40`	`39`	`}`
`41`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ impl QueueProvider {`
`19`	`19`	`let mut map = HashMap::new();`
`20`	`20`
`21`	`21`	`for template in template_provider.get_templates().await? {`
`22`		`- map.insert(String::from(&template.name), RwLock::new(Queue::new()));`
	`22`	`+ map.insert(template.name.to_owned(), RwLock::new(Queue::new()));`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`Ok(QueueProvider { queue_map: map })`
Original file line number	Diff line number	Diff line change
`@@ -64,10 +64,7 @@ impl Task for QueueTask {`
`64`	`64`	`if group_size <= available_slots {`
`65`	`65`	`available_slots -= group_size;`
`66`	`66`
`67`		`- epsilon_api.send(SendToServer(`
`68`		`- group,`
`69`		`- instance.metadata.name.as_ref().unwrap().clone(),`
`70`		`- ));`
	`67`	`+ epsilon_api.send(SendToServer(group, instance.get_name()));`
`71`	`68`	`}`
`72`	`69`	`}`
`73`	`70`	`}`