Visual Elements¶

package main

import (
    "log"
    "net/http"
    "time"

    "your_project_path/internal/api"
    "your_project_path/internal/auth"
    "your_project_path/internal/client"
    "your_project_path/internal/config"
    "your_project_path/internal/handlers"
)

func main() {
    cfg, err := config.LoadConfig("config.yaml") // Or path from env var
    if err != nil {
        log.Fatalf("Failed to load configuration: %v", err)
    }

    // Initialize AuthProvider (example: simple token)
    // For production, use a more secure provider or one that handles token refresh.
    var authProvider auth.AuthProvider
    if cfg.Client.AuthToken != "" {
        authProvider = auth.NewSimpleTokenAuthProvider(cfg.Client.AuthToken)
    } else {
        // Potentially initialize a more complex auth provider, e.g., OAuth2 or JWT with login
        log.Println("Warning: No auth_token configured, using nil AuthProvider or fallback.")
        // authProvider = auth.NewOAuthProvider(...) 
    }

    httpClient := &http.Client{Timeout: time.Duration(cfg.Client.Timeout)}

    // Initialize BaseClient with config for retries and circuit breaker
    baseClient := client.NewBaseClient(
        cfg.Client.BaseURL,
        httpClient,
        authProvider,
        client.WithRetryPolicy(cfg.Client.Retry), // Assuming WithRetryPolicy takes your RetryConfig struct
        client.WithCircuitBreakerPolicy(cfg.Client.CircuitBreaker), // Assuming WithCBPolicy
    )

    // Initialize specialized clients
    eventApiClient := api.NewEventClient(baseClient)
    // chatApiClient := api.NewChatClient(baseClient)
    // ... other clients

    // Setup webhook handler with the Event API client
    http.HandleFunc(cfg.WebhookListener.Path, handlers.WebhookHandler(eventApiClient, cfg.WebhookListener.SecretKey))

    serverAddr := cfg.WebhookListener.Host + ":" + cfg.WebhookListener.Port
    log.Printf("MFO Client listening on %s%s", serverAddr, cfg.WebhookListener.Path)
    if err := http.ListenAndServe(serverAddr, nil); err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}

// From internal/handlers/webhook_handler.go
package handlers

import (
    "context"
    "encoding/json"
    "log"
    "net/http"
    "time"

    "your_project_path/internal/api"    // For EventClientInterface
    "your_project_path/internal/models" // For your Event struct
)

func WebhookHandler(eventClient api.EventClientInterface, webhookSecret string) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // IMPORTANT: Implement robust signature verification using webhookSecret first!
        // if !auth.VerifySignature(r, webhookSecret) {
        //    http.Error(w, "Invalid signature", http.StatusUnauthorized)
        //    return
        // }

        var receivedEvent models.Event // Adjust to your specific event model
        if err := json.NewDecoder(r.Body).Decode(&receivedEvent); err != nil {
            http.Error(w, "Invalid event payload", http.StatusBadRequest)
            log.Printf("Error decoding webhook event: %v", err)
            return
        }
        defer r.Body.Close()

        log.Printf("Received webhook: Type '%s'", receivedEvent.Type)

        // Asynchronously forward the event using the structured API client
        go func(eventToForward models.Event) {
            ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) // Example timeout
            defer cancel()

            // The EventClient handles authentication, retries, etc., via BaseClient
            apiResponse, err := eventClient.SendEvent(ctx, eventToForward)
            if err != nil {
                log.Printf("Error forwarding event to MFO server via EventClient: %v", err)
                // Implement more sophisticated error handling here if needed (e.g., dead-letter queue)
            } else {
                log.Printf("Event forwarded successfully by EventClient. MFO Response ID: %s", apiResponse.ID) // Assuming apiResponse has an ID
            }
        }(receivedEvent)

        w.WriteHeader(http.StatusAccepted)
        fmt.Fprintln(w, "Event received and is being processed.")
    }
}

// From internal/api/event_client.go (Conceptual)
package api

import (
    "context"
    "your_project_path/internal/models"
)

type EventClient struct {
    base BaseClientInterface // Injected BaseClient
}

func NewEventClient(base BaseClientInterface) *EventClient {
    return &EventClient{base: base}
}

func (c *EventClient) SendEvent(ctx context.Context, eventData models.Event) (*models.EventResponse, error) {
    var response models.EventResponse
    // Path should be a constant or from config
    err := c.base.Post(ctx, "/api/v1/events", eventData, &response)
    if err != nil {
        return nil, err // BaseClient handles APIError creation, retries, etc.
    }
    return &response, nil
}

import (
    "errors"
    "log"
    "your_project_path/internal/models" // Where APIError is defined
)

func handleSomeApiCall() {
    // response, err := someApiClient.SomeOperation(context.Background(), requestData)
    var err error // Placeholder for an actual API call error
    if err != nil {
        var apiErr *models.APIError
        var retryableErr *models.RetryableError // Assuming you have this wrapper
        var cbErr *models.CircuitBreakerError // Assuming you have this

        if errors.As(err, &apiErr) {
            log.Printf("MFO API Error: Status %d, Code '%s', Message: %s", apiErr.StatusCode, apiErr.Code, apiErr.Message)
            if apiErr.StatusCode == http.StatusUnauthorized {
                log.Println("Authentication failed. Token might be expired or invalid.")
                // Trigger re-authentication or alert
            } else if apiErr.StatusCode >= 500 {
                log.Println("MFO Server error. This might have been retried based on policy.")
            }
        } else if errors.As(err, &retryableErr) {
            log.Printf("Operation failed but was deemed retryable. Original error: %v. Retry After: %v", 
                retryableErr.OriginalError, retryableErr.RetryAfter)
        } else if errors.As(err, &cbErr) {
            log.Printf("Circuit Breaker is open for service '%s'. State: %s", cbErr.ServiceName, cbErr.State)
        } else {
            // Network error or other non-API specific error that might have exhausted retries
            log.Printf("Operation failed due to an unexpected error: %v", err)
        }
        return
    }
    // log.Printf("Operation successful: %v", response)
}

// From internal/config/config.go
package config

import (
    "os"
    "time"
    "gopkg.in/yaml.v3"
)

// Duration is a helper for unmarshalling time.Duration from strings like "30s".
type Duration time.Duration

func (d *Duration) UnmarshalYAML(value *yaml.Node) error {
    dur, err := time.ParseDuration(value.Value)
    if err != nil { return err }
    *d = Duration(dur)
    return nil
}

// ClientConfig holds settings for API client communication.
type ClientConfig struct {
    BaseURL        string        `yaml:"base_url"`
    AuthBaseURL    string        `yaml:"auth_base_url,omitempty"`
    AuthToken      string        `yaml:"auth_token,omitempty"`
    Timeout        Duration      `yaml:"timeout"`
    Retry          RetryConfig   `yaml:"retry"`
    CircuitBreaker CBConfig      `yaml:"circuit_breaker"`
}

// RetryConfig defines the retry policy.
type RetryConfig struct {
    MaxAttempts       int      `yaml:"max_attempts"`
    InitialBackoff    Duration `yaml:"initial_backoff"`
    MaxBackoff        Duration `yaml:"max_backoff"`
    BackoffMultiplier float64  `yaml:"backoff_multiplier"`
}

// CBConfig defines the circuit breaker policy.
type CBConfig struct {
    FailureThreshold int      `yaml:"failure_threshold"`
    ResetTimeout     Duration `yaml:"reset_timeout"`
}

// WebhookListenerConfig holds settings for the webhook listener.
type WebhookListenerConfig struct {
    Host      string `yaml:"host"`
    Port      string `yaml:"port"`
    Path      string `yaml:"path"`
    SecretKey string `yaml:"secret_key"`
}

// LoggingConfig holds settings for logging.
type LoggingConfig struct {
    Level  string `yaml:"level"`
    Format string `yaml:"format"`
}

// Config is the top-level configuration structure.
type Config struct {
    Client           ClientConfig          `yaml:"client"`
    WebhookListener  WebhookListenerConfig `yaml:"webhook_listener"`
    Logging          LoggingConfig         `yaml:"logging,omitempty"`
}

// LoadConfig loads YAML configuration from file, expanding environment variables.
func LoadConfig(filePath string) (*Config, error) {
    data, err := os.ReadFile(filePath)
    if err != nil { return nil, err }
    expandedData := os.ExpandEnv(string(data))
    var cfg Config
    if err := yaml.Unmarshal([]byte(expandedData), &cfg); err != nil { return nil, err }
    return &cfg, nil
}