Upgrade to Rust 1.82

.github/workflows/ci.yml

@@ -5,7 +5,7 @@ on:
 
 name: Continuous integration
 env:
-  latest_version: "1.81.0"
+  latest_version: "1.82.0"
 
 jobs:
   test:

example_apps/console/src/model/mod.rs

@@ -160,7 +160,7 @@ pub enum AppCommand {
     Quit,
     Clear,
     Help { command_name: Option<String> },
-    Controller(ControllerCommand),
+    Controller(Box<ControllerCommand>),
 }
 
 #[derive(Debug)]

example_apps/console/src/model/parse/mod.rs

@@ -103,9 +103,9 @@ pub fn parse_app_command(command: &str) -> Result<AppCommand, Cow<'static, str>>
         }),
         ["quit"] => Ok(AppCommand::Quit),
         ["clear"] => Ok(AppCommand::Clear),
-        _ => Ok(AppCommand::Controller(parse_controller_command(
+        _ => Ok(AppCommand::Controller(Box::new(parse_controller_command(
             command_parts.as_slice(),
-        )?)),
+        )?))),
     }
 }
 

example_apps/console/src/model/parse/tests.rs

@@ -105,7 +105,7 @@ fn mixed_tokens3() {
 
 fn to_controller(cmd: AppCommand) -> ControllerCommand {
     if let AppCommand::Controller(c) = cmd {
-        c
+        *c
     } else {
         panic!("Unexpected command kind.");
     }

example_apps/console/src/ui/mod.rs

@@ -434,7 +434,7 @@ fn on_command(
         Ok(AppCommand::Clear) => None,
         Ok(AppCommand::Controller(command)) => Some(
             controller
-                .perform_action(command)
+                .perform_action(*command)
                 .into_iter()
                 .map(|msg| format!("{}\n", msg))
                 .map(Cow::Owned)

server/swimos_connector_fluvio/src/ingress/mod.rs

@@ -112,7 +112,7 @@ where
         let relays = relays.clone();
 
         Ok(unfold(
-            ConnectorState::Uninit(configuration.clone(), factory.clone()),
+            ConnectorState::Uninit(Box::new(configuration.clone()), factory.clone()),
             move |state: ConnectorState<F::Client, F>| {
                 let topic = topic.clone();
                 let key_deser = key_deser.clone();
@@ -122,28 +122,29 @@ where
 
                 let fut = async move {
                     match state {
-                        ConnectorState::Uninit(config, factory) => match factory.open(config).await
-                        {
-                            Ok(consumer) => {
-                                let (key, value) =
-                                    match load_deserializers(key_deser, value_deser).await {
-                                        Ok((key, value)) => (key, value),
-                                        Err(e) => {
-                                            return Some((
-                                                Err(FluvioConnectorError::Configuration(e)),
-                                                ConnectorState::Failed,
-                                            ))
-                                        }
-                                    };
-                                poll_dispatch(
-                                    consumer,
-                                    topic,
-                                    MessageSelector::new(key, value, lanes, relays),
-                                )
-                                .await
+                        ConnectorState::Uninit(config, factory) => {
+                            match factory.open(*config).await {
+                                Ok(consumer) => {
+                                    let (key, value) =
+                                        match load_deserializers(key_deser, value_deser).await {
+                                            Ok((key, value)) => (key, value),
+                                            Err(e) => {
+                                                return Some((
+                                                    Err(FluvioConnectorError::Configuration(e)),
+                                                    ConnectorState::Failed,
+                                                ))
+                                            }
+                                        };
+                                    poll_dispatch(
+                                        consumer,
+                                        topic,
+                                        MessageSelector::new(key, value, lanes, relays),
+                                    )
+                                    .await
+                                }
+                                Err(e) => Some((Err(e), ConnectorState::Failed)),
                             }
-                            Err(e) => Some((Err(e), ConnectorState::Failed)),
-                        },
+                        }
                         ConnectorState::Running {
                             topic,
                             consumer,
@@ -185,7 +186,7 @@ where
 }
 
 enum ConnectorState<C, F> {
-    Uninit(FluvioIngressConfiguration, F),
+    Uninit(Box<FluvioIngressConfiguration>, F),
     Running {
         topic: String,
         consumer: C,