Mgo与Go应用中的连接池与TCP超时管理

package main

import (
    "log"
    "time"

    "gopkg.in/mgo.v2"
)

// Global session variable for master session
var masterSession *mgo.Session

func init() {
    // Initialize the master session with appropriate timeouts
    dialInfo := &mgo.DialInfo{
        Addrs:    []string{"localhost:27017"}, // MongoDB server address
        Timeout:  10 * time.Second,             // Connection and operation timeout
        Database: "mydatabase",                 // Default database
        Username: "myuser",                     // Optional: username
        Password: "mypassword",                 // Optional: password
        // Other options like PoolLimit, Source, etc. can be configured here
    }

    var err error
    masterSession, err = mgo.DialWithInfo(dialInfo)
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }

    // Set a consistent read mode, e.g., Monotonic for eventual consistency
    masterSession.SetMode(mgo.Monotonic, true)
    log.Println("Successfully connected to MongoDB.")
}

// GetSession provides a copy of the master session for each request
func GetSession() *mgo.Session {
    return masterSession.Copy()
}

func main() {
    defer masterSession.Close() // Ensure the master session is closed on app exit

    // Example usage in an API handler or service function
    session := GetSession()
    defer session.Close() // Important: Close the session copy after use

    // Perform database operations here
    collection := session.DB("mydatabase").C("mycollection")

    // Example: Insert a document
    err := collection.Insert(map[string]string{"name": "Test Document", "status": "active"})
    if err != nil {
        log.Printf("Error inserting document: %v", err)
        // Handle specific errors, e.g., timeout
        if mgo.Is = true { // Check for timeout error type
            log.Println("Operation timed out, consider refreshing session or retrying.")
            // Optionally, try to refresh the master session if the error is persistent and affects all copies
            // masterSession.Refresh()
        }
    } else {
        log.Println("Document inserted successfully.")
    }

    // ... more operations
}

// In an API handler or service method
func handleRequest(masterSession *mgo.Session) error {
    s := masterSession.Copy() // Get a fresh copy for this operation
    defer s.Close()           // Ensure the copy is closed

    collection := s.DB("mydatabase").C("mycollection")
    var result MyStruct
    err := collection.Find(bson.M{"_id": "some_id"}).One(&result)

    if err != nil {
        if err == mgo.ErrNotFound {
            return fmt.Errorf("document not found")
        }
        // Generic error handling for database operations
        log.Printf("Database operation failed: %v", err)
        // If it's a timeout or network error, closing the current copy (via defer)
        // ensures the next operation gets a potentially healthier connection.
        // For persistent issues affecting the master session, a periodic refresh
        // or health check on the master session might be considered, though less common.
        return fmt.Errorf("database error: %w", err)
    }
    return nil
}