chore: Return error as a variant type from downgrader

Means we can return errors in the version expected by the
client since they need to go to the client anyways, and usually
pass through the connector without parsing.

buttplug/src/core/connector/in_process_connector.rs

···
         } else {
           ButtplugServerMessageV3::Error(ButtplugError::from(ButtplugMessageError::MessageConversionError("In-process connector messages should never have differing versions.".to_owned())).into())
         }
-        Err(e) => e.into()
+        Err(e) => if let ButtplugServerMessageVariant::V3(msg) = e {
+          msg
+        } else {
+          ButtplugServerMessageV3::Error(ButtplugError::from(ButtplugMessageError::MessageConversionError("In-process connector messages should never have differing versions.".to_owned())).into())
+        }
       };
       sender
         .send(output)

buttplug/src/server/server_downgrade_wrapper.rs

···
 
 use std::{fmt, sync::Arc};
 
-use crate::core::message::{self, ButtplugClientMessageVariant, ButtplugMessageSpecVersion, ButtplugServerMessageV4, ButtplugServerMessageVariant};
+use crate::core::message::{self, ButtplugClientMessageVariant, ButtplugMessageSpecVersion, ButtplugServerMessageV4, ButtplugServerMessageVariant, ErrorV0};
 
 use super::{device::ServerDeviceManager, server_message_conversion::ButtplugServerMessageConverter, ButtplugServer, ButtplugServerResultFuture};
 use futures::{future::{self, BoxFuture, FutureExt}, Stream};
···
     self.server.disconnect()
   }
 
+  pub fn spec_version(&self) -> Option<ButtplugMessageSpecVersion> {
+    self.spec_version.get().copied()
+  }
+
   pub fn client_version_event_stream(&self) -> impl Stream<Item = ButtplugServerMessageVariant> {
     let spec_version = self.spec_version.clone();
     self.server.event_stream().map(move |m| {
···
   pub fn parse_message(
     &self,
     msg: ButtplugClientMessageVariant,
-  ) -> BoxFuture<'static, Result<ButtplugServerMessageVariant, message::ErrorV0>> {
+  ) -> BoxFuture<'static, Result<ButtplugServerMessageVariant, ButtplugServerMessageVariant>> {
     error!("{:?}", msg);
     match msg {
       ButtplugClientMessageVariant::V4(msg) => {
         let fut = self.server.parse_message(msg);
         async move {
-          Ok(fut.await?.into())
+          Ok(fut.await.map_err(|e| ButtplugServerMessageVariant::from(ButtplugServerMessageV4::from(e)))?.into())
         }.boxed()
       }
       msg => {
         let v = msg.version();
         let converter = ButtplugServerMessageConverter::new(Some(msg));
+        let spec_version = *self.spec_version.get_or_init(|| {
+          info!("Setting Buttplug Server Message Spec Downgrade version to {}", v);
+          v
+        } );
         match converter.convert_incoming(&self.server.device_manager()) {
           Ok(converted_msg) => {
             let fut = self.server.parse_message(converted_msg);
-            let spec_version = *self.spec_version.get_or_init(|| {
-              info!("Setting Buttplug Server Message Spec Downgrade version to {}", v);
-              v
-            } );
             async move {
-              let result = fut.await?;
-              converter.convert_outgoing(&result, &spec_version).map_err(|e| e.into())
+              let result = fut.await.map_err(|e| converter.convert_outgoing(&e.into(), &spec_version).unwrap())?;
+              converter.convert_outgoing(&result, &spec_version).map_err(|e| converter.convert_outgoing(&&ButtplugServerMessageV4::from(ErrorV0::from(e)), &spec_version).unwrap())
             }.boxed()
           }
-          Err(e) => future::ready(Err(e.into())).boxed()
+          Err(e) => future::ready(Err(converter.convert_outgoing(&ButtplugServerMessageV4::from(ErrorV0::from(e)), &spec_version).unwrap())).boxed()
         }
       }
     }

buttplug/tests/test_server.rs

···
     device::{
       hardware::{HardwareCommand, HardwareWriteCmd},
       ServerDeviceManagerBuilder,
-    },
-    ButtplugServerBuilder, ButtplugServerDowngradeWrapper,
+    }, ButtplugServerBuilder, ButtplugServerDowngradeWrapper
   },
 };
 use futures::{pin_mut, Stream, StreamExt};
···
   // assert_eq!(server.server_name, "Test Server");
   let result = server.parse_message(msg.try_into().unwrap()).await;
   assert!(result.is_err());
-  assert!(matches!(
-    result.unwrap_err().original_error(),
-    ButtplugError::ButtplugHandshakeError(ButtplugHandshakeError::RequestServerInfoExpected)
-  ));
+  if let Err(ButtplugServerMessageVariant::V3(ButtplugServerMessageV3::Error(e))) = result {
+    assert!(matches!(
+      e.original_error(),
+      ButtplugError::ButtplugHandshakeError(ButtplugHandshakeError::RequestServerInfoExpected)
+    ));
+  } else {
+    panic!("Should've gotten error")
+  }
   assert!(!server.connected());
 }
 
···
   let (server, _recv) = setup_test_server((msg.clone()).into()).await;
   assert!(server.connected());
   let err = server.parse_message(message::ButtplugClientMessageVariant::V3(msg.into())).await.unwrap_err();
-  assert!(matches!(
-    err.original_error(),
-    ButtplugError::ButtplugHandshakeError(ButtplugHandshakeError::HandshakeAlreadyHappened)
-  ));
+  if let ButtplugServerMessageVariant::V3(ButtplugServerMessageV3::Error(e)) = err {
+    assert!(matches!(
+      e.original_error(),
+      ButtplugError::ButtplugHandshakeError(ButtplugHandshakeError::HandshakeAlreadyHappened)
+    ));
+  } else {
+    panic!("Should've gotten error")
+  }
+
 }
 
 #[tokio::test]
 async fn test_invalid_device_index() {
   let msg = message::RequestServerInfoV1::new("Test Client", BUTTPLUG_CURRENT_MESSAGE_SPEC_VERSION);
   let (server, _) = setup_test_server(msg.into()).await;
-  let reply = server
+  let err = server
     .parse_message(message::ButtplugClientMessageVariant::V3(message::VibrateCmdV1::new(10, vec![]).into()))
-    .await;
-  assert!(reply.is_err());
-  assert!(matches!(
-    reply.unwrap_err().original_error(),
-    ButtplugError::ButtplugDeviceError(ButtplugDeviceError::DeviceNotAvailable(_))
-  ));
+    .await
+    .unwrap_err();
+  if let ButtplugServerMessageVariant::V3(ButtplugServerMessageV3::Error(e)) = err {
+    assert!(matches!(
+      e.original_error(),
+      ButtplugError::ButtplugDeviceError(ButtplugDeviceError::DeviceNotAvailable(_))
+    ));
+  } else {
+    panic!("Should've gotten error")
+  }  
 }
 
 #[tokio::test]

buttplug/tests/test_server_device.rs

···
 mod util;
 use buttplug::core::{
   errors::{ButtplugDeviceError, ButtplugError},
-  message::{self, ButtplugClientMessageVariant, ButtplugServerMessageV3, ButtplugServerMessageVariant, Endpoint, BUTTPLUG_CURRENT_MESSAGE_SPEC_VERSION},
+  message::{self, ButtplugClientMessageV4, ButtplugClientMessageVariant, ButtplugServerMessageV3, ButtplugServerMessageV4, ButtplugServerMessageVariant, Endpoint, BUTTPLUG_CURRENT_MESSAGE_SPEC_VERSION},
 };
 use futures::{pin_mut, StreamExt};
 use std::matches;
 pub use util::test_device_manager::TestDeviceCommunicationManagerBuilder;
-use util::test_server_with_device;
+use util::{test_server_with_device, test_server_v4_with_device};
 
 // Test devices that have protocols that support movements not all devices do.
 // For instance, the Onyx+ is part of a protocol that supports vibration, but
···
 
 #[tokio::test]
 async fn test_reject_on_no_raw_message() {
-  let (server, _) = test_server_with_device("Massage Demo", false);
-  let recv = server.client_version_event_stream();
+  let (server, _) = test_server_v4_with_device("Massage Demo", false);
+  let recv = server.event_stream();
   pin_mut!(recv);
   assert!(server
     .parse_message(
-      ButtplugClientMessageVariant::V3(message::RequestServerInfoV1::new("Test Client", BUTTPLUG_CURRENT_MESSAGE_SPEC_VERSION).into())
+      ButtplugClientMessageV4::from(message::RequestServerInfoV1::new("Test Client", BUTTPLUG_CURRENT_MESSAGE_SPEC_VERSION))
     )
     .await
     .is_ok());
   assert!(server
-    .parse_message(ButtplugClientMessageVariant::V3(message::StartScanningV0::default().into()))
+    .parse_message(ButtplugClientMessageV4::from(message::StartScanningV0::default()))
     .await
     .is_ok());
   while let Some(msg) = recv.next().await {
-    if let ButtplugServerMessageVariant::V3(ButtplugServerMessageV3::ScanningFinished(_)) = msg {
+    if let ButtplugServerMessageV4::ScanningFinished(_) = msg {
       continue;
-    } else if let ButtplugServerMessageVariant::V3(ButtplugServerMessageV3::DeviceAdded(da)) = msg {
+    } else if let ButtplugServerMessageV4::DeviceAdded(da) = msg {
       assert_eq!(da.device_name(), "Aneros Vivi");
       let mut should_be_err;
       should_be_err = server
         .parse_message(
-          ButtplugClientMessageVariant::V3(message::RawWriteCmdV2::new(da.device_index(), Endpoint::Tx, &[0x0], false).into()),
+          ButtplugClientMessageV4::from(message::RawWriteCmdV2::new(da.device_index(), Endpoint::Tx, &[0x0], false)),
         )
         .await;
       assert!(should_be_err.is_err());
···
       ));
 
       should_be_err = server
-        .parse_message(ButtplugClientMessageVariant::V3(message::RawReadCmdV2::new(da.device_index(), Endpoint::Tx, 0, 0).into()))
+        .parse_message(ButtplugClientMessageV4::from(message::RawReadCmdV2::new(da.device_index(), Endpoint::Tx, 0, 0)))
         .await;
       assert!(should_be_err.is_err());
       assert!(matches!(
···
       ));
 
       should_be_err = server
-        .parse_message(ButtplugClientMessageVariant::V3(message::RawSubscribeCmdV2::new(da.device_index(), Endpoint::Tx).into()))
+        .parse_message(ButtplugClientMessageV4::from(message::RawSubscribeCmdV2::new(da.device_index(), Endpoint::Tx)))
         .await;
       assert!(should_be_err.is_err());
       assert!(matches!(
···
       ));
 
       should_be_err = server
-        .parse_message(ButtplugClientMessageVariant::V3(message::RawUnsubscribeCmdV2::new(da.device_index(), Endpoint::Tx).into()))
+        .parse_message(ButtplugClientMessageV4::from(message::RawUnsubscribeCmdV2::new(da.device_index(), Endpoint::Tx)))
         .await;
       assert!(should_be_err.is_err());
       assert!(matches!(

buttplug/tests/util/device_test/client/client_v2/in_process_connector.rs

···
         } else {
           ButtplugServerMessageV2::Error(ButtplugError::from(ButtplugMessageError::MessageConversionError("In-process connector messages should never have differing versions.".to_owned())).into())
         }
-        Err(e) => e.into()
+        Err(e) => if let ButtplugServerMessageVariant::V2(msg) = e {
+          msg
+        } else {
+          ButtplugServerMessageV2::Error(ButtplugError::from(ButtplugMessageError::MessageConversionError("In-process connector messages should never have differing versions.".to_owned())).into())
+        }
       };
       sender
         .send(output)

buttplug/tests/util/mod.rs

···
     device,
   )
 }
+
+#[allow(dead_code)]
+pub fn test_server_v4_with_device(
+  device_type: &str,
+  allow_raw_message: bool,
+) -> (ButtplugServer, TestDeviceChannelHost) {
+  let mut builder = TestDeviceCommunicationManagerBuilder::default();
+  let device = builder.add_test_device(&TestDeviceIdentifier::new(device_type, None));
+
+  (
+    test_server_with_comm_manager(builder, allow_raw_message),
+    device,
+  )
+}

buttplug/tests/util/test_server.rs

···
                 }
               },
               Err(err_msg) => {
-                if connector_clone.send(ButtplugServerMessageVariant::V3(err_msg.into())).await.is_err() {
+                if connector_clone.send(err_msg).await.is_err() {
                   error!("Cannot send reply to server, dropping and assuming remote server thread has exited.");
                 }
               }