rocketmq-auth 1.0.0

// Copyright 2023 The RocketMQ Rust Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! # Authentication Strategy Usage Example
//!
//! This example demonstrates how to use the AuthenticationStrategy trait
//! and its implementations.

use std::sync::Arc;

use cheetah_string::CheetahString;
use rocketmq_auth::AllowAllAuthenticationStrategy;
use rocketmq_auth::AuthFailureKind;
use rocketmq_auth::AuthOperation;
use rocketmq_auth::AuthServiceError;
use rocketmq_auth::AuthenticationFuture;
use rocketmq_auth::AuthenticationStrategy;
use rocketmq_auth::DefaultAuthenticationContext;

/// Example 1: Using AllowAllAuthenticationStrategy
async fn example_allow_all_strategy() {
    println!("=== Example 1: AllowAllAuthenticationStrategy ===");

    // Create the strategy
    let strategy = AllowAllAuthenticationStrategy::new();

    // Create an authentication context
    let mut context = DefaultAuthenticationContext::new();
    context.set_username(CheetahString::from("testuser"));

    // Authenticate - this will always succeed
    match strategy.authenticate(&context).await {
        Ok(()) => println!("[OK] Authentication succeeded (as expected)"),
        Err(e) => println!("[FAIL] Authentication failed: {}", e),
    }

    println!();
}

/// Example 2: Using dynamic dispatch with trait objects
async fn example_dynamic_dispatch() {
    println!("=== Example 2: Dynamic Dispatch ===");

    // Store strategies in a vector using trait objects
    let strategies: Vec<Arc<dyn AuthenticationStrategy>> = vec![
        Arc::new(AllowAllAuthenticationStrategy::new()),
        // In production, you would add other strategies here:
        // Arc::new(AkSkAuthenticationStrategy::new()),
        // Arc::new(TokenAuthenticationStrategy::new()),
    ];

    let context = DefaultAuthenticationContext::new();

    // Authenticate using each strategy
    for (i, strategy) in strategies.iter().enumerate() {
        match strategy.authenticate(&context).await {
            Ok(()) => println!("[OK] Strategy {} succeeded", i + 1),
            Err(e) => println!("[FAIL] Strategy {} failed: {}", i + 1, e),
        }
    }

    println!();
}

/// Example 3: Custom authentication strategy
struct CustomAuthenticationStrategy {
    allowed_users: Vec<String>,
}

impl CustomAuthenticationStrategy {
    fn new(allowed_users: Vec<String>) -> Self {
        Self { allowed_users }
    }
}

impl AuthenticationStrategy for CustomAuthenticationStrategy {
    fn authenticate<'a>(&'a self, context: &'a dyn rocketmq_auth::AuthenticationContext) -> AuthenticationFuture<'a> {
        Box::pin(async move {
            // Downcast to DefaultAuthenticationContext
            let ctx = context
                .as_any()
                .downcast_ref::<DefaultAuthenticationContext>()
                .ok_or_else(|| AuthServiceError::new(AuthOperation::BuildContext, AuthFailureKind::InvalidInput))?;

            // Check if username is in allowed list
            if let Some(username) = ctx.username() {
                if self.allowed_users.contains(&username.to_string()) {
                    return Ok(());
                }
                return Err(AuthServiceError::new(
                    AuthOperation::Authenticate,
                    AuthFailureKind::Unauthenticated,
                ));
            }

            Err(AuthServiceError::new(
                AuthOperation::Authenticate,
                AuthFailureKind::Unauthenticated,
            ))
        })
    }
}

async fn example_custom_strategy() {
    println!("=== Example 3: Custom Authentication Strategy ===");

    // Create a custom strategy with allowed users
    let strategy =
        CustomAuthenticationStrategy::new(vec!["alice".to_string(), "bob".to_string(), "charlie".to_string()]);

    // Test with allowed user
    let mut context1 = DefaultAuthenticationContext::new();
    context1.set_username(CheetahString::from("alice"));
    match strategy.authenticate(&context1).await {
        Ok(()) => println!("[OK] User 'alice' authenticated successfully"),
        Err(e) => println!("[FAIL] User 'alice' failed: {}", e),
    }

    // Test with disallowed user
    let mut context2 = DefaultAuthenticationContext::new();
    context2.set_username(CheetahString::from("eve"));
    match strategy.authenticate(&context2).await {
        Ok(()) => println!("[OK] User 'eve' authenticated successfully"),
        Err(e) => println!("[FAIL] User 'eve' failed: {}", e),
    }

    // Test with missing username
    let context3 = DefaultAuthenticationContext::new();
    match strategy.authenticate(&context3).await {
        Ok(()) => println!("[OK] Empty username authenticated successfully"),
        Err(e) => println!("[FAIL] Empty username failed: {}", e),
    }

    println!();
}

/// Example 4: Strategy composition
async fn example_strategy_composition() {
    println!("=== Example 4: Strategy Composition ===");

    // In a real application, you might have a chain of strategies
    let strategies: Vec<Arc<dyn AuthenticationStrategy>> = vec![
        Arc::new(AllowAllAuthenticationStrategy::new()),
        Arc::new(CustomAuthenticationStrategy::new(vec!["admin".to_string()])),
    ];

    let mut context = DefaultAuthenticationContext::new();
    context.set_username(CheetahString::from("admin"));

    // Try each strategy until one succeeds
    let mut authenticated = false;
    for strategy in &strategies {
        if strategy.authenticate(&context).await.is_ok() {
            authenticated = true;
            println!("[OK] Authenticated using a strategy");
            break;
        }
    }

    if !authenticated {
        println!("[FAIL] All strategies failed");
    }

    println!();
}

#[tokio::main]
async fn main() {
    println!("RocketMQ Rust - Authentication Strategy Examples\n");

    example_allow_all_strategy().await;
    example_dynamic_dispatch().await;
    example_custom_strategy().await;
    example_strategy_composition().await;

    println!("All examples completed!");
}