🔍 Code Extractor

Asynchronous main entry point function that initializes and runs an email forwarding SMTP server with logging, configuration validation, and graceful shutdown handling.

Purpose

This function serves as the primary application entry point for an email forwarding service. It orchestrates the complete lifecycle of the application including: setting up logging infrastructure, validating configuration settings, creating and starting an SMTP server instance, registering signal handlers for graceful shutdown on SIGINT/SIGTERM signals, and handling fatal errors with appropriate cleanup. The function is designed to run indefinitely until interrupted by signals or fatal errors.

Source Code

async def main():
    """Main application entry point."""
    
    # Set up logging
    setup_logging()
    
    # Print banner
    print_banner()
    
    try:
        # Validate configuration
        settings.validate_config()
        logger.info("Configuration validated successfully")
        
        # Create and start SMTP server
        smtp_server = SMTPServer()
        
        # Set up graceful shutdown
        def signal_handler(signum, frame):
            logger.info(f"Received signal {signum}, initiating shutdown...")
            smtp_server.stop()
            sys.exit(0)
            
        signal.signal(signal.SIGINT, signal_handler)
        signal.signal(signal.SIGTERM, signal_handler)
        
        # Start server
        logger.info("Starting Email Forwarder service...")
        await smtp_server.run_forever()
        
    except KeyboardInterrupt:
        logger.info("Received keyboard interrupt, shutting down...")
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        sys.exit(1)
    finally:
        logger.info("Email Forwarder service stopped")

Return Value

This function does not return any value (implicitly returns None). It runs indefinitely until interrupted by a signal (SIGINT/SIGTERM) or a fatal exception occurs, at which point it exits the process with status code 0 (graceful shutdown) or 1 (error condition).

Dependencies

• asyncio
• logging
• sys
• signal

Required Imports

import asyncio
import logging
import sys
import signal
from datetime import datetime
from config import settings
from utils.logger import setup_logging
from forwarder.smtp_server import SMTPServer

Usage Example

import asyncio
import logging
import sys
import signal
from datetime import datetime
from config import settings
from utils.logger import setup_logging
from forwarder.smtp_server import SMTPServer

async def main():
    """Main application entry point."""
    setup_logging()
    print_banner()
    try:
        settings.validate_config()
        logger.info("Configuration validated successfully")
        smtp_server = SMTPServer()
        def signal_handler(signum, frame):
            logger.info(f"Received signal {signum}, initiating shutdown...")
            smtp_server.stop()
            sys.exit(0)
        signal.signal(signal.SIGINT, signal_handler)
        signal.signal(signal.SIGTERM, signal_handler)
        logger.info("Starting Email Forwarder service...")
        await smtp_server.run_forever()
    except KeyboardInterrupt:
        logger.info("Received keyboard interrupt, shutting down...")
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        sys.exit(1)
    finally:
        logger.info("Email Forwarder service stopped")

if __name__ == "__main__":
    asyncio.run(main())

Best Practices

• This function must be run using asyncio.run(main()) or equivalent async event loop
• Ensure all required configuration settings are properly set before calling this function
• The function registers signal handlers which may interfere with other signal handling in the application - avoid multiple signal handler registrations
• The SMTPServer class must implement stop() and run_forever() methods for proper operation
• Logging should be configured to handle concurrent async operations if the SMTP server processes multiple connections
• The function calls sys.exit() which terminates the entire process - ensure all cleanup is handled in the finally block or signal handlers
• On Windows, SIGTERM may not be available - consider platform-specific signal handling if cross-platform support is needed
• The print_banner() function is called but not imported in the provided imports list - ensure this function is available in scope
• Consider implementing a timeout mechanism for smtp_server.run_forever() to prevent indefinite hanging
• The signal_handler function is synchronous but calls smtp_server.stop() - ensure stop() is safe to call from signal handlers

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• function main_v53 77.4% similar

  Entry point function that validates the working directory and starts an email forwarding service.

  From: /tf/active/vicechatdev/email-forwarder/run_service.py

• function main_v69 73.6% similar

  Command-line interface function that parses arguments and sends a test email through an SMTP forwarder service, displaying connection details and returning an exit code based on success.

  From: /tf/active/vicechatdev/email-forwarder/send_test_email.py

• function run_smtp_server 70.0% similar

  Initializes and runs an asynchronous SMTP server using a new event loop, with proper error handling and graceful shutdown.

  From: /tf/active/vicechatdev/email-forwarder/src/forwarder/smtp_server.py

• function run_server 69.9% similar

  Initializes and runs an asynchronous SMTP server with platform-specific event loop configuration and error handling.

  From: /tf/active/vicechatdev/email-forwarder/src/main.py

• function start_service 67.0% similar

  Orchestrates the startup sequence for an email forwarder service by validating environment, dependencies, configuration, and project structure before launching the main application.

  From: /tf/active/vicechatdev/email-forwarder/run_service.py