Implement From for KeygenEvent and PublicKey

2 files changed, 41 insertions, 37 deletions

diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 530078f9a2..d9e77f556b 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -18,7 +18,7 @@ use mullvad_types::{
     settings::Settings,
     states::{TargetState, TunnelState},
     version,
-    wireguard::{self, RotationInterval, RotationIntervalError},
+    wireguard::{RotationInterval, RotationIntervalError},
 };
 use parking_lot::RwLock;
 use std::{
@@ -641,7 +641,7 @@ impl ManagementService for ManagementServiceImpl {
         self.send_command_to_daemon(DaemonCommand::GenerateWireguardKey(tx))?;
         self.wait_for_result(rx)
             .await?
-            .map(|event| Response::new(convert_wireguard_key_event(&event)))
+            .map(|event| Response::new(types::KeygenEvent::from(event)))
             .map_err(map_daemon_error)
     }
 
@@ -651,7 +651,7 @@ impl ManagementService for ManagementServiceImpl {
         self.send_command_to_daemon(DaemonCommand::GetWireguardKey(tx))?;
         let key = self.wait_for_result(rx).await?.map_err(map_daemon_error)?;
         match key {
-            Some(key) => Ok(Response::new(convert_public_key(&key))),
+            Some(key) => Ok(Response::new(types::PublicKey::from(key))),
             None => Err(Status::not_found("no WireGuard key was found")),
         }
     }
@@ -762,36 +762,6 @@ impl ManagementServiceImpl {
     }
 }
 
-fn convert_wireguard_key_event(
-    event: &mullvad_types::wireguard::KeygenEvent,
-) -> types::KeygenEvent {
-    use mullvad_types::wireguard::KeygenEvent::*;
-    use types::keygen_event::KeygenEvent as ProtoEvent;
-
-    types::KeygenEvent {
-        event: match event {
-            NewKey(_) => i32::from(ProtoEvent::NewKey),
-            TooManyKeys => i32::from(ProtoEvent::TooManyKeys),
-            GenerationFailure => i32::from(ProtoEvent::GenerationFailure),
-        },
-        new_key: if let NewKey(key) = event {
-            Some(convert_public_key(&key))
-        } else {
-            None
-        },
-    }
-}
-
-fn convert_public_key(public_key: &wireguard::PublicKey) -> types::PublicKey {
-    types::PublicKey {
-        key: public_key.key.as_bytes().to_vec(),
-        created: Some(types::Timestamp {
-            seconds: public_key.created.timestamp(),
-            nanos: 0,
-        }),
-    }
-}
-
 fn convert_state(state: TunnelState) -> types::TunnelState {
     use talpid_types::tunnel::{
         ActionAfterDisconnect, ErrorStateCause, FirewallPolicyError, ParameterGenerationError,
@@ -1054,17 +1024,19 @@ impl EventListener for ManagementInterfaceEventBroadcaster {
 
     fn notify_app_version(&self, app_version_info: version::AppVersionInfo) {
         log::debug!("Broadcasting new app version info");
-        let new_info = types::AppVersionInfo::from(app_version_info);
         self.notify(types::DaemonEvent {
-            event: Some(daemon_event::Event::VersionInfo(new_info)),
+            event: Some(daemon_event::Event::VersionInfo(
+                types::AppVersionInfo::from(app_version_info),
+            )),
         })
     }
 
     fn notify_key_event(&self, key_event: mullvad_types::wireguard::KeygenEvent) {
         log::debug!("Broadcasting new wireguard key event");
-        let new_event = convert_wireguard_key_event(&key_event);
         self.notify(types::DaemonEvent {
-            event: Some(daemon_event::Event::KeyEvent(new_event)),
+            event: Some(daemon_event::Event::KeyEvent(types::KeygenEvent::from(
+                key_event,
+            ))),
         })
     }
 }
diff --git a/mullvad-management-interface/src/types.rs b/mullvad-management-interface/src/types.rs
index bb90225745..4c058bac89 100644
--- a/mullvad-management-interface/src/types.rs
+++ b/mullvad-management-interface/src/types.rs
@@ -5,6 +5,38 @@ use std::convert::TryFrom;
 
 tonic::include_proto!("mullvad_daemon.management_interface");
 
+impl From<mullvad_types::wireguard::KeygenEvent> for KeygenEvent {
+    fn from(event: mullvad_types::wireguard::KeygenEvent) -> Self {
+        use keygen_event::KeygenEvent as Event;
+        use mullvad_types::wireguard::KeygenEvent as MullvadEvent;
+
+        KeygenEvent {
+            event: match event {
+                MullvadEvent::NewKey(_) => i32::from(Event::NewKey),
+                MullvadEvent::TooManyKeys => i32::from(Event::TooManyKeys),
+                MullvadEvent::GenerationFailure => i32::from(Event::GenerationFailure),
+            },
+            new_key: if let MullvadEvent::NewKey(key) = event {
+                Some(PublicKey::from(key))
+            } else {
+                None
+            },
+        }
+    }
+}
+
+impl From<mullvad_types::wireguard::PublicKey> for PublicKey {
+    fn from(public_key: mullvad_types::wireguard::PublicKey) -> Self {
+        PublicKey {
+            key: public_key.key.as_bytes().to_vec(),
+            created: Some(Timestamp {
+                seconds: public_key.created.timestamp(),
+                nanos: 0,
+            }),
+        }
+    }
+}
+
 impl From<mullvad_types::version::AppVersionInfo> for AppVersionInfo {
     fn from(version_info: mullvad_types::version::AppVersionInfo) -> Self {
         Self {