fix: ServerManager spawn_mock_server function now handles mock servers provided by plugins

Author: rholshausen

pact_mock_server/src/builder.rs

@@ -2,6 +2,7 @@
 
 use std::net::Ipv4Addr;
 #[allow(unused_imports)] use anyhow::{anyhow, Context};
+use itertools::Either;
 use pact_models::pact::Pact;
 use pact_models::PactSpecification;
 use pact_models::v4::pact::V4Pact;
@@ -20,8 +21,10 @@ use crate::server_manager::ServerManager;
 
 /// Builder for constructing mock servers
 pub struct MockServerBuilder {
-  config: MockServerConfig,
-  pact: V4Pact
+  /// Mock server configuration
+  pub config: MockServerConfig,
+  /// Pact to use for the mock server interactions
+  pub pact: V4Pact
 }
 
 impl MockServerBuilder {
@@ -161,6 +164,35 @@ impl MockServerBuilder {
 
   /// Set the transport to use. The default transports are 'http' and 'https'. Additional transports
   /// can be provided by plugins.
+  ///
+  /// Note that plugin mock servers can only be supported by assigning this builder to a
+  /// `ServerManager`, which will interact with the plugin driver to start the plugin mock server
+  /// correctly.
+  /// For instance:
+  /// ```no_run
+  /// # use pact_models::pact::Pact;
+  /// # use pact_models::v4::pact::V4Pact;
+  /// # use pact_mock_server::builder::MockServerBuilder;
+  /// # use pact_mock_server::server_manager::ServerManager;
+  /// # #[tokio::main]
+  /// # async fn main() -> anyhow::Result<()> {
+  /// # let some_grpc_pact = V4Pact::default().boxed();
+  /// // This won't work
+  /// let mock_server_details = MockServerBuilder::new()
+  ///    .with_pact(some_grpc_pact.boxed())
+  ///    .with_transport("grpc")?
+  ///    .start()
+  ///    .await?;
+  ///
+  /// // Instead, assign it to a server manager
+  /// let mut manager = ServerManager::new();
+  /// let builder = MockServerBuilder::new()
+  ///    .with_pact(some_grpc_pact.boxed())
+  ///    .with_transport("grpc")?;
+  /// let mock_server_details = builder.attach_to_manager(&mut manager)?;
+  /// # Ok::<(), anyhow::Error>(())
+  /// # }
+  /// ```
   #[cfg(feature = "plugins")]
   pub fn with_transport<S: Into<String>>(mut self, transport: S) -> anyhow::Result<Self> {
     let transport = transport.into();
@@ -194,15 +226,24 @@ impl MockServerBuilder {
   pub fn attach_to_global_manager(self) -> anyhow::Result<MockServer> {
     let mut guard = MANAGER.lock().unwrap();
     let manager = guard.get_or_insert_with(|| ServerManager::new());
-    manager.spawn_mock_server(self)
+    manager.spawn_http_mock_server(self)
   }
 
   /// Starts the mockserver, consuming this builder and registers it with the server manager.
   /// The mock server tasks will be spawned on the server manager's runtime.
-  /// Returns the mock server instance.
-  pub fn attach_to_manager(self, manager: &mut ServerManager) -> anyhow::Result<MockServer> {
+  /// Returns the mock server instance, unless the mock server was provided by a plugin, in which
+  /// case it just returns the mock server ID and port.
+  pub fn attach_to_manager(
+    self, manager:
+    &mut ServerManager
+  ) -> anyhow::Result<Either<MockServer, (String, u16)>> {
     manager.spawn_mock_server(self)
   }
+  
+  /// Returns a clone of the config within this builder
+  pub fn config(&self) -> MockServerConfig {
+    self.config.clone()
+  }
 }
 
 #[cfg(test)]

pact_mock_server/src/server_manager.rs

@@ -5,7 +5,7 @@
 use std::collections::BTreeMap;
 use std::ffi::CString;
 #[cfg(feature = "plugins")] use std::future::Future;
-use std::net::SocketAddr;
+use std::net::{Ipv6Addr, SocketAddr};
 #[cfg(feature = "plugins")] use std::net::ToSocketAddrs;
 
 use anyhow::anyhow;
@@ -75,7 +75,77 @@ impl ServerManager {
 
   /// Consumes the mock server builder, and then spawns the resulting mock server on the server
   /// manager's runtime. Note that this function will block the current calling thread.
-  pub fn spawn_mock_server(&mut self, builder: MockServerBuilder) -> anyhow::Result<MockServer> {
+  ///
+  /// The returned value depends on whether the mock server is directly managed by this manager
+  /// or provided by a plugin. For plugin provided mock servers, the function will return the
+  /// mock server ID and port.
+  pub fn spawn_mock_server(
+    &mut self,
+    builder: MockServerBuilder
+  ) -> anyhow::Result<Either<MockServer, (String, u16)>> {
+    #[cfg(feature = "plugins")]
+    {
+      if let Some(transport) = builder.config.transport_entry.clone() {
+        if transport.provider_type == CatalogueEntryProviderType::PLUGIN {
+          let config = builder.config;
+          let mut pact = builder.pact;
+
+          for interaction in pact.interactions.iter_mut() {
+            if let None = interaction.transport() {
+              interaction.set_transport(transport.key.split("/").last().map(|i| i.to_string()));
+            }
+          }
+
+          let address = if config.address.is_empty() {
+            SocketAddr::new(Ipv6Addr::LOCALHOST.into(), 0)
+          } else {
+            config.address.parse()?
+          };
+
+          let mock_server_config = pact_plugin_driver::mock_server::MockServerConfig {
+            output_path: None,
+            host_interface: Some(address.ip().to_string()),
+            port: address.port() as u32,
+            tls: false
+          };
+          let test_context = hashmap! {};
+          let result = self.runtime.block_on(
+            pact_plugin_driver::plugin_manager::start_mock_server_v2(&transport, pact.boxed(),
+              mock_server_config, test_context)
+          )?;
+          let port = result.port as u16;
+          let id = result.key.clone();
+          self.mock_servers.insert(
+            id.clone(),
+            ServerEntry {
+              mock_server: Either::Right(PluginMockServer {
+                mock_server_details: result,
+                catalogue_entry: transport,
+                pact
+              }),
+              port,
+              resources: vec![]
+            }
+          );
+
+          Ok(Either::Right((id, port)))
+        } else {
+          self.spawn_http_mock_server(builder).map(Either::Left)
+        }
+      } else {
+        self.spawn_http_mock_server(builder).map(Either::Left)
+      }
+    }
+
+    #[cfg(not(feature = "plugins"))]
+    self.spawn_http_mock_server(builder).map(Either::Left)
+  }
+
+  /// Consumes the mock server builder, and then spawns the resulting HTTP mock server on the server
+  /// manager's runtime. Note that this function will block the current calling thread.
+  ///
+  /// This function does not handle mock servers provided by plugins.
+  pub fn spawn_http_mock_server(&mut self, builder: MockServerBuilder) -> anyhow::Result<MockServer> {
     #[allow(unused_assignments)]
     let mut mock_server = MockServer::default();
 

pact_mock_server/src/tests.rs

@@ -215,7 +215,7 @@ fn match_request_with_header_with_multiple_values() -> anyhow::Result<()> {
     .with_v4_pact(pact)
     .with_id(id.clone())
     .bind_to("127.0.0.1:0");
-  let result = manager.spawn_mock_server(mock_server_builder);
+  let result = manager.spawn_http_mock_server(mock_server_builder);
   let mock_server = result.unwrap();
   let port = mock_server.port();
 

pact_mock_server_cli/src/server.rs

@@ -154,18 +154,30 @@ fn start_provider(context: &mut WebmachineContext) -> Result<bool, u16> {
           }
 
           match result {
-            Ok(mock_server) => {
-              debug!("Mock server started on port {}", mock_server.port());
-              let mock_server_json = json!({
-                "id" : json!(mock_server_id),
-                "port" : json!(mock_server.port() as i64),
-              });
+            Ok(mock_server_details) => {
+              let mock_server_json = match mock_server_details {
+                Either::Left(mock_server) => {
+                  debug!("Mock server started on port {}", mock_server.port());
+                  json!({
+                    "id" : mock_server_id,
+                    "port" : mock_server.port()
+                  })
+                }
+                Either::Right((id, port)) => {
+                  debug!("Plugin Mock server started on port {}", port);
+                  json!({
+                    "id" : id,
+                    "port" : port,
+                  })
+                }
+              };
+
               let json_response = json!({ "mockServer" : mock_server_json });
               context.response.body = Some(Bytes::from(json_response.to_string()));
               context.response.add_header("Location",
                 vec![HeaderValue::basic(format!("/mockserver/{}", mock_server_id).as_str())]);
               Ok(true)
-            },
+            }
             Err(msg) => {
               context.response.body = Some(json_error(format!("Failed to start mock server - {}", msg)));
               Err(422)
@@ -193,7 +205,7 @@ fn start_https_server(
   config: MockServerConfig,
   port: u16,
   id: &String
-) -> anyhow::Result<MockServer> {
+) -> anyhow::Result<Either<MockServer, (String, u16)>> {
   debug!("Starting TLS mock server with id {}", id);
   let mut server_manager = SERVER_MANAGER.lock().unwrap();
   trace!("Unlocked server manager");