chore: Fix naming, exiting for Engine REST API server

crates/intiface_engine/src/engine.rs

···
       .clone();
 
     if let Some(rest_port) = options.rest_api_port() {
-      IntifaceRestServer::run(server).await;
+      select! {
+        _ = self.stop_token.cancelled() => {
+          info!("Owner requested process exit, exiting.");
+        }
+        res = IntifaceRestServer::run(rest_port, server) => {
+          info!("Rest API listener stopped, exiting.");
+          if let Err(e) = res {
+            error!("Error running Intiface Central RestAPI Server: {:?}", e);
+          }
+        }
+      };
+      if let Some(frontend) = &frontend {
+        frontend.send(EngineMessage::EngineStopped {}).await;
+        tokio::time::sleep(Duration::from_millis(100)).await;
+        frontend.disconnect();
+      }
       return Ok(());
     }
 

crates/intiface_engine/src/rest_server.rs

···
 
 async fn set_device_output(
   State(client): State<Arc<ButtplugClient>>,
-  Path((index, command, level)): Path<(u32, OutputType, f64)>,
+  Path((index, output_type, level)): Path<(u32, OutputType, f64)>,
 ) -> Result<(), IntifaceRestError> {
-  let cmd = ClientDeviceOutputCommand::from_command_value_float(command, level)
+  let cmd = ClientDeviceOutputCommand::from_command_value_float(output_type, level)
     .map_err(IntifaceRestError::ButtplugClientError)?;
 
   get_device(&client, index)?
···
 
 async fn set_feature_output(
   State(client): State<Arc<ButtplugClient>>,
-  Path((index, feature_index, command, level)): Path<(u32, u32, OutputType, f64)>,
+  Path((index, feature_index, output_type, level)): Path<(u32, u32, OutputType, f64)>,
 ) -> Result<(), IntifaceRestError> {
-  let cmd = ClientDeviceOutputCommand::from_command_value_float(command, level)
+  let cmd = ClientDeviceOutputCommand::from_command_value_float(output_type, level)
     .map_err(IntifaceRestError::ButtplugClientError)?;
 
   get_feature(&client, index, feature_index)?
···
 
 async fn server_sse(
   State(client): State<Arc<ButtplugClient>>,
-) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
+) -> Sse<impl Stream<Item = Result<Event, Infallible>>> { 
   let stream = client
     .event_stream()
     .map(|e| Ok(Event::default().data(format!("{:?}", e))));
···
 }
 
 impl IntifaceRestServer {
-  pub async fn run(server: ButtplugServer) -> Result<(), io::Error> {
+  pub async fn run(port: u16, server: ButtplugServer) -> Result<(), io::Error> {
     let connector = ButtplugInProcessClientConnectorBuilder::default()
       .server(server)
       .finish();
···
         .route("/devices/{index}/features", get(get_features))
         .route("/devices/{index}/features/{index}/", put(get_feature_info))
         .route(
-          "/devices/{index}/outputs/{command}/{level}",
+          "/devices/{index}/outputs/{output_type}/{level}",
           put(set_device_output),
         )
         .route(
···
     );
 
     // write address like this to not make typos
-    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+    let addr = SocketAddr::from(([127, 0, 0, 1], port));
+    info!("Buttplug REST API Server now listening on {:?}", addr);
     let listener = TcpListener::bind(addr).await?;
-
     axum::serve(listener, app.into_make_service()).await?;
 
     Ok(())