feat: extract service integrations into separate crates

Cargo.toml

@@ -20,7 +20,8 @@ exclude = [
   "resources/persist",
   "resources/secrets",
   "resources/shared-db",
-  "resources/static-folder"
+  "resources/static-folder",
+  "integrations"
 ]
 
 [workspace.package]

codegen/src/shuttle_main/mod.rs

@@ -37,7 +37,7 @@ struct Input {
     /// The identifier for a resource input
     ident: Ident,
 
-    /// The shuttle_service builder for this resource
+    /// The shuttle_runtime builder for this resource
     builder: Builder,
 }
 
@@ -144,9 +144,9 @@ fn check_return_type(signature: Signature) -> Option<TypePath> {
         ReturnType::Default => {
             emit_error!(
                 signature,
-                "shuttle_service::main functions need to return a service";
+                "shuttle_runtime::main functions need to return a service";
                 hint = "See the docs for services with first class support";
-                doc = "https://docs.rs/shuttle-service/latest/shuttle_service/attr.main.html#shuttle-supported-services"
+                doc = "https://docs.rs/shuttle-service/latest/shuttle_runtime/attr.main.html#shuttle-supported-services"
             );
             None
         }
@@ -155,9 +155,9 @@ fn check_return_type(signature: Signature) -> Option<TypePath> {
             _ => {
                 emit_error!(
                     r#type,
-                    "shuttle_service::main functions need to return a first class service or 'Result<impl Service, shuttle_service::Error>";
+                    "shuttle_runtime::main functions need to return a first class service or 'Result<impl Service, shuttle_runtime::Error>";
                     hint = "See the docs for services with first class support";
-                    doc = "https://docs.rs/shuttle-service/latest/shuttle_service/attr.main.html#shuttle-supported-services"
+                    doc = "https://docs.rs/shuttle-service/latest/shuttle_runtime/attr.main.html#shuttle-supported-services"
                 );
                 None
             }
@@ -213,7 +213,7 @@ impl ToTokens for Loader {
             None
         } else {
             Some(parse_quote!(
-                use shuttle_service::ResourceBuilder;
+                use shuttle_runtime::ResourceBuilder;
             ))
         };
 
@@ -222,16 +222,16 @@ impl ToTokens for Loader {
                 mut #factory_ident: shuttle_runtime::ProvisionerFactory<S>,
                 logger: shuttle_runtime::Logger,
             ) -> #return_type {
-                use shuttle_service::Context;
-                use shuttle_service::tracing_subscriber::prelude::*;
+                use shuttle_runtime::Context;
+                use shuttle_runtime::tracing_subscriber::prelude::*;
                 #extra_imports
 
                 let filter_layer =
-                    shuttle_service::tracing_subscriber::EnvFilter::try_from_default_env()
-                        .or_else(|_| shuttle_service::tracing_subscriber::EnvFilter::try_new("INFO"))
+                    shuttle_runtime::tracing_subscriber::EnvFilter::try_from_default_env()
+                        .or_else(|_| shuttle_runtime::tracing_subscriber::EnvFilter::try_new("INFO"))
                         .unwrap();
 
-                shuttle_service::tracing_subscriber::registry()
+                shuttle_runtime::tracing_subscriber::registry()
                     .with(filter_layer)
                     .with(logger)
                     .init();
@@ -281,15 +281,15 @@ mod tests {
                 mut _factory: shuttle_runtime::ProvisionerFactory<S>,
                 logger: shuttle_runtime::Logger,
             ) -> ShuttleSimple {
-                use shuttle_service::Context;
-                use shuttle_service::tracing_subscriber::prelude::*;
+                use shuttle_runtime::Context;
+                use shuttle_runtime::tracing_subscriber::prelude::*;
 
                 let filter_layer =
-                    shuttle_service::tracing_subscriber::EnvFilter::try_from_default_env()
-                        .or_else(|_| shuttle_service::tracing_subscriber::EnvFilter::try_new("INFO"))
+                    shuttle_runtime::tracing_subscriber::EnvFilter::try_from_default_env()
+                        .or_else(|_| shuttle_runtime::tracing_subscriber::EnvFilter::try_new("INFO"))
                         .unwrap();
 
-                shuttle_service::tracing_subscriber::registry()
+                shuttle_runtime::tracing_subscriber::registry()
                     .with(filter_layer)
                     .with(logger)
                     .init();
@@ -361,16 +361,16 @@ mod tests {
                 mut factory: shuttle_runtime::ProvisionerFactory<S>,
                 logger: shuttle_runtime::Logger,
             ) -> ShuttleComplex {
-                use shuttle_service::Context;
-                use shuttle_service::tracing_subscriber::prelude::*;
-                use shuttle_service::ResourceBuilder;
+                use shuttle_runtime::Context;
+                use shuttle_runtime::tracing_subscriber::prelude::*;
+                use shuttle_runtime::ResourceBuilder;
 
                 let filter_layer =
-                    shuttle_service::tracing_subscriber::EnvFilter::try_from_default_env()
-                        .or_else(|_| shuttle_service::tracing_subscriber::EnvFilter::try_new("INFO"))
+                    shuttle_runtime::tracing_subscriber::EnvFilter::try_from_default_env()
+                        .or_else(|_| shuttle_runtime::tracing_subscriber::EnvFilter::try_new("INFO"))
                         .unwrap();
 
-                shuttle_service::tracing_subscriber::registry()
+                shuttle_runtime::tracing_subscriber::registry()
                     .with(filter_layer)
                     .with(logger)
                     .init();
@@ -489,16 +489,16 @@ mod tests {
                 mut factory: shuttle_runtime::ProvisionerFactory<S>,
                 logger: shuttle_runtime::Logger,
             ) -> ShuttleComplex {
-                use shuttle_service::Context;
-                use shuttle_service::tracing_subscriber::prelude::*;
-                use shuttle_service::ResourceBuilder;
+                use shuttle_runtime::Context;
+                use shuttle_runtime::tracing_subscriber::prelude::*;
+                use shuttle_runtime::ResourceBuilder;
 
                 let filter_layer =
-                    shuttle_service::tracing_subscriber::EnvFilter::try_from_default_env()
-                        .or_else(|_| shuttle_service::tracing_subscriber::EnvFilter::try_new("INFO"))
+                    shuttle_runtime::tracing_subscriber::EnvFilter::try_from_default_env()
+                        .or_else(|_| shuttle_runtime::tracing_subscriber::EnvFilter::try_new("INFO"))
                         .unwrap();
 
-                shuttle_service::tracing_subscriber::registry()
+                shuttle_runtime::tracing_subscriber::registry()
                     .with(filter_layer)
                     .with(logger)
                     .init();

integrations/README.md

@@ -0,0 +1,5 @@
+## Service Integrations
+The list of supported frameworks for shuttle is always growing. If you feel we are missing a framework you would like, then feel to create a feature request for your desired framework.
+
+## Writing your own service integration
+Creating your own service integration is quite simple. You only need to implement the [`Service`](https://docs.rs/shuttle-service/latest/shuttle_service/trait.Service.html) trait for your framework.

integrations/shuttle-actix-web/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "shuttle-actix-web"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+actix-web = { version = "4.3.1" }
+shuttle-runtime = { path = "../../runtime", version = "0.1.0" }
+num_cpus = "1.15.0"

integrations/shuttle-actix-web/src/lib.rs

@@ -0,0 +1,60 @@
+//! Shuttle service integration for the Actix Web framework.
+//! ## Example
+//! ```rust,no_run
+//! use actix_web::{get, web::ServiceConfig};
+//! use shuttle_actix_web::ShuttleActixWeb;
+//!
+//! #[get("/hello")]
+//! async fn hello_world() -> &'static str {
+//!     "Hello World!"
+//! }
+//!
+//! #[shuttle_runtime::main]
+//! async fn actix_web(
+//! ) -> ShuttleActixWeb<impl FnOnce(&mut ServiceConfig) + Send + Clone + 'static> {
+//!     let config = move |cfg: &mut ServiceConfig| {
+//!         cfg.service(hello_world);
+//!     };
+//!
+//!     Ok(config.into())
+//! }
+//! ```
+use std::net::SocketAddr;
+
+/// A wrapper type for a closure that returns an [actix_web::web::ServiceConfig] so we can implement
+/// [shuttle_runtime::Service] for it.
+#[derive(Clone)]
+pub struct ActixWebService<F>(pub F);
+
+#[shuttle_runtime::async_trait]
+impl<F> shuttle_runtime::Service for ActixWebService<F>
+where
+    F: FnOnce(&mut actix_web::web::ServiceConfig) + Send + Clone + 'static,
+{
+    async fn bind(mut self, addr: SocketAddr) -> Result<(), shuttle_runtime::Error> {
+        // Start a worker for each cpu, but no more than 4.
+        let worker_count = num_cpus::get().min(4);
+
+        let server =
+            actix_web::HttpServer::new(move || actix_web::App::new().configure(self.0.clone()))
+                .workers(worker_count)
+                .bind(addr)?
+                .run();
+
+        server.await.map_err(shuttle_runtime::CustomError::new)?;
+
+        Ok(())
+    }
+}
+
+impl<F> From<F> for ActixWebService<F>
+where
+    F: FnOnce(&mut actix_web::web::ServiceConfig) + Send + Clone + 'static,
+{
+    fn from(service_config: F) -> Self {
+        Self(service_config)
+    }
+}
+
+/// The return type that should be returned from the [shuttle_runtime::main] function.
+pub type ShuttleActixWeb<F> = Result<ActixWebService<F>, shuttle_runtime::Error>;

integrations/shuttle-axum/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "shuttle-axum"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+axum = { version = "0.6.10" }
+shuttle-runtime = { path = "../../runtime", version = "0.1.0" }

integrations/shuttle-axum/src/lib.rs

@@ -0,0 +1,43 @@
+//! Shuttle service integration for the Axum web framework.
+//! ## Example
+//! ```rust,no_run
+//! use axum::{routing::get, Router};
+//!
+//! async fn hello_world() -> &'static str {
+//!     "Hello, world!"
+//! }
+//!
+//! #[shuttle_runtime::main]
+//! async fn axum() -> shuttle_axum::ShuttleAxum {
+//!     let router = Router::new().route("/hello", get(hello_world));
+//!
+//!     Ok(router.into())
+//! }
+//! ```
+use shuttle_runtime::{CustomError, Error};
+use std::net::SocketAddr;
+
+/// A wrapper type for [axum::Router] so we can implement [shuttle_runtime::Service] for it.
+pub struct AxumService(pub axum::Router);
+
+#[shuttle_runtime::async_trait]
+impl shuttle_runtime::Service for AxumService {
+    /// Takes the router that is returned by the user in their [shuttle_runtime::main] function
+    /// and binds to an address passed in by shuttle.
+    async fn bind(mut self, addr: SocketAddr) -> Result<(), Error> {
+        axum::Server::bind(&addr)
+            .serve(self.0.into_make_service())
+            .await
+            .map_err(CustomError::new)?;
+
+        Ok(())
+    }
+}
+
+impl From<axum::Router> for AxumService {
+    fn from(router: axum::Router) -> Self {
+        Self(router)
+    }
+}
+/// The return type that should be returned from the [shuttle_runtime::main] function.
+pub type ShuttleAxum = Result<AxumService, Error>;

integrations/shuttle-poem/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "shuttle-poem"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+poem = { version = "1.3.55" }
+shuttle-runtime = { path = "../../runtime", version = "0.1.0" }

integrations/shuttle-poem/src/lib.rs

@@ -0,0 +1,49 @@
+//! Shuttle service integration for the Poem web framework.
+//! ## Example
+//! ```rust,no_run
+//! use poem::{get, handler, Route};
+//! use shuttle_poem::ShuttlePoem;
+//!
+//! #[handler]
+//! fn hello_world() -> &'static str {
+//!     "Hello, world!"
+//! }
+//!
+//! #[shuttle_runtime::main]
+//! async fn poem() -> ShuttlePoem<impl poem::Endpoint> {
+//!     let app = Route::new().at("/hello", get(hello_world));
+//!
+//!     Ok(app.into())
+//! }
+//!
+//! ```
+
+/// A wrapper type for [poem::Endpoint] so we can implement [shuttle_runtime::Service] for it.
+pub struct PoemService<T>(pub T);
+
+#[shuttle_runtime::async_trait]
+impl<T> shuttle_runtime::Service for PoemService<T>
+where
+    T: poem::Endpoint + Send + 'static,
+{
+    async fn bind(mut self, addr: std::net::SocketAddr) -> Result<(), shuttle_runtime::Error> {
+        poem::Server::new(poem::listener::TcpListener::bind(addr))
+            .run(self.0)
+            .await
+            .map_err(shuttle_runtime::CustomError::new)?;
+
+        Ok(())
+    }
+}
+
+impl<T> From<T> for PoemService<T>
+where
+    T: poem::Endpoint + Send + 'static,
+{
+    fn from(router: T) -> Self {
+        Self(router)
+    }
+}
+
+/// The return type that should be returned from the [shuttle_runtime::main] function.
+pub type ShuttlePoem<T> = Result<PoemService<T>, shuttle_runtime::Error>;

integrations/shuttle-poise/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "shuttle-poise"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+poise = { version = "0.5.2" }
+shuttle-runtime = { path = "../../runtime", version = "0.1.0" }