Struct MicrokernelServer

pub struct MicrokernelServer<P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static, S: OAuthStorage + Clone + 'static> { /* private fields */ }

Microkernel server builder that composes independent handlers

This builder demonstrates the microkernel principle where services are composed from independent, single-responsibility components. Now supports any OAuth provider and storage backend through trait abstraction.

Implementations

impl<P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static, S: OAuthStorage + Clone + 'static> MicrokernelServer<P, S>

pub fn new() -> Self

Create a new microkernel server builder

pub fn with_oauth_provider(self, oauth_provider: OAuthProvider<P, S>) -> Self

Add OAuth provider handler

pub fn with_streamable_handler( self, streamable_handler: StreamableHttpHandler<P, S>, ) -> Self

Add streamable HTTP handler

pub fn with_sse_handler( self, sse_handler: SseHandler<P, S>, config: SseHandlerConfig, ) -> Self

Add SSE handler with configuration

pub fn build_router(self) -> AppResult<Router>

Build the composed router from all registered handlers

This method demonstrates the microkernel composition principle where independent components are combined into a unified service.

pub async fn serve(self, bind_address: SocketAddr) -> AppResult<()>

Start the microkernel server

Examples found in repository

examples/oauth_standard_mcp_server.rs (line 36)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting MCP OAuth server with microkernel architecture...");

    // Create OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: config.github.client_id.clone(),
        client_secret: config.github.client_secret.clone(),
        redirect_uri: config.github.redirect_uri.clone(),
        scope: config.github.scope.clone(),
        provider_name: "github".to_string(),
    };
    let oauth_provider = GitHubOAuthProvider::new_github(github_config);

    // Log configuration
    log_startup_info(&config);

    // Create microkernel server with all handlers composed
    let microkernel = create_full_github_microkernel(oauth_provider);

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    microkernel.serve(bind_address).await?;

    Ok(())
}

examples/oauth_cognito_mcp_server.rs (line 41)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting MCP OAuth server with Cognito and microkernel architecture...");

    // Create Cognito OAuth provider
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: config.cognito.redirect_uri.clone(),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };
    let oauth_provider = CognitoOAuthProvider::new_cognito(
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
    );

    // Log configuration
    log_startup_info(&config);

    // Create microkernel server with all handlers composed
    let microkernel = create_full_cognito_microkernel(oauth_provider);

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    microkernel.serve(bind_address).await?;

    Ok(())
}

examples/oauth_cognito_dynamodb_mcp_server.rs (line 110)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting MCP OAuth server with Cognito and DynamoDB storage...");

    // Create Cognito OAuth configuration
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: format!(
            "http://{}:{}/oauth/callback",
            config.server.host, config.server.port
        ),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };

    // Get DynamoDB configuration
    let table_name =
        env::var("DYNAMODB_TABLE_NAME").unwrap_or_else(|_| "oauth-storage".to_string());
    let create_table = env::var("DYNAMODB_CREATE_TABLE")
        .unwrap_or_else(|_| "true".to_string())
        .parse::<bool>()
        .unwrap_or(true);

    // Log configuration
    log_startup_info(&config, &table_name, create_table);

    // Create microkernel server with Cognito OAuth and DynamoDB storage
    let microkernel = create_full_cognito_microkernel_dynamodb(
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
        table_name,
        create_table,
    )
    .await
    .map_err(|e| {
        remote_mcp_kernel::error::AppError::Internal(format!("Failed to create microkernel: {}", e))
    })?;

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    microkernel.serve(bind_address).await?;

    Ok(())
}

Trait Implementations

impl<P: OAuthProviderTrait<S, DefaultClientManager<S>>, S: OAuthStorage + Clone + 'static> Default for MicrokernelServer<P, S>

fn default() -> Self

Returns the “default value” for a type.