diff --git a/noxis-rs/src/utils/prcs.rs b/noxis-rs/src/utils/prcs.rs
index bb0b94d..3f10903 100644
--- a/noxis-rs/src/utils/prcs.rs
+++ b/noxis-rs/src/utils/prcs.rs
@@ -15,32 +15,32 @@ pub mod v2 {
     use super::*;
     
     #[derive(Debug)]
-    pub struct ProcessesController<'a> {
-        name: &'a str,
+    pub struct ProcessesController {
+        name: Arc<str>,
         bin: String,
         // obj: Arc<TrackingProcess>,
         state: ProcessState,
-        event_reader: MpscReciever<Events<'a>>,
-        negative_events: HashSet<&'a str>,
+        event_reader: MpscReciever<Events>,
+        negative_events: HashSet<Arc<str>>,
     }
 
-    impl<'a> PartialEq for ProcessesController<'a> {
+    impl PartialEq for ProcessesController {
         fn eq(&self, other: &Self) -> bool {
             self.bin == other.bin
         }
     }
 
-    impl<'a> ProcessesController<'a> {
-        pub fn new(name: &'a str, event_reader: MpscReciever<Events<'a>>) -> ProcessesController<'a> {
+    impl ProcessesController {
+        pub fn new(name: &str, event_reader: MpscReciever<Events>) -> ProcessesController {
             ProcessesController {
-                name,
-                bin: String::new(),
+                name : Arc::from(name),
+                bin : String::new(),
                 state : ProcessState::Stopped,
                 event_reader,
                 negative_events : HashSet::new(),
             }
         }
-        pub fn with_exe(mut self, bin: impl AsRef<Path>) -> ProcessesController<'a> {
+        pub fn with_exe(mut self, bin: impl AsRef<Path>) -> ProcessesController {
             self.bin = bin.as_ref().to_string_lossy().into_owned();
             self
         }
@@ -51,22 +51,22 @@ pub mod v2 {
                     info!("Event on {} `{}` for {}. Ignoring ...", dep_type, dep_name, self.name);
                 },
                 "stop" => {
-                    if is_active(self.name).await {
+                    if is_active(&self.name).await {
                         info!("Event on {} `{}` for {}. Stopping ...", dep_type, dep_name, self.name);
-                        terminate_process(self.name).await;
+                        terminate_process(&self.name).await;
                         self.state = ProcessState::Stopped;
                     }
                 },
                 "hold" => {
-                    if !is_frozen(self.name).await {
+                    if !is_frozen(&self.name).await {
                         info!("Event on {} `{}` for {}. Freezing ...", dep_type, dep_name, self.name);
-                        freeze_process(self.name).await;
+                        freeze_process(&self.name).await;
                         self.state = ProcessState::Holding;
                     }
                 },
                 "restart" => {
                     info!("Event on {} `{}` for {}. Restarting ...", dep_type, dep_name, self.name);
-                    let _ = restart_process(self.name, &self.bin).await;
+                    let _ = restart_process(&self.name, &self.bin).await;
                 },
                 _ => error!("Impermissible trigger in file-trigger for {}. Ignoring event ...", self.name),
             }
@@ -75,13 +75,13 @@ pub mod v2 {
     }
 
     #[async_trait]
-    impl<'a> ProcessUnit<'a> for ProcessesController<'a> {
-        async fn process(&'a mut self) {
+    impl ProcessUnit for ProcessesController {
+        async fn process(&mut self) {
             if self.negative_events.len() == 0 {
                 match self.state {
                     ProcessState::Holding => {
                         info!("No negative dependecies events on {} process. Unfreezing ...", self.name);
-                        if let Err(er) = unfreeze_process(self.name).await {
+                        if let Err(er) = unfreeze_process(&self.name).await {
                             error!("Cannot unfreeze process {} : {}", self.name, er);
                         } else {
                             self.state = ProcessState::Pending;
@@ -89,7 +89,7 @@ pub mod v2 {
                     }, 
                     ProcessState::Stopped => {
                         info!("No negative dependecies events on {} process. Starting ...", self.name);
-                        if let Err(er) = start_process(self.name, &self.bin).await {
+                        if let Err(er) = start_process(&self.name, &self.bin).await {
                             error!("Cannot start process {} : {}", self.name, er);
                         } else {
                             self.state = ProcessState::Pending;
@@ -101,8 +101,8 @@ pub mod v2 {
             while let Ok(event) = self.event_reader.try_recv() {
                 match event {
                     Events::Positive(target) => {
-                        if self.negative_events.contains(target) {
-                            self.negative_events.remove(target);
+                        if self.negative_events.contains(&target) {
+                            self.negative_events.remove(&target);
                         }
                     },
                     Events::Negative(event) => {
@@ -110,12 +110,12 @@ pub mod v2 {
                             NegativeOutcomes::FileWasChanged(target, dep_type, trigger) |
                             NegativeOutcomes::FileWasMovedOrDeleted(target, dep_type, trigger) |
                             NegativeOutcomes::ServiceIsUnreachable(target, dep_type, trigger) => {
-                                if !self.negative_events.contains(target) {
-                                    self.negative_events.insert(target);
+                                if !self.negative_events.contains(&target) {
+                                    self.negative_events.insert(target.clone());
                                 
                                     self.trigger_on(
-                                        target, 
-                                        trigger, 
+                                        &target, 
+                                        &trigger, 
                                         dep_type
                                     ).await;
                                 }
diff --git a/noxis-rs/src/utils/services.rs b/noxis-rs/src/utils/services.rs
index 0b048e5..f5d8ff1 100644
--- a/noxis-rs/src/utils/services.rs
+++ b/noxis-rs/src/utils/services.rs
@@ -1,5 +1,4 @@
-use crate::options::structs::{CustomError, Services};
-use super::prcs::{is_active, is_frozen};
+use crate::options::structs::CustomError;
 use log::{error, warn};
 use std::net::{TcpStream, ToSocketAddrs};
 use std::sync::Arc;