Go Mgo 应用中连接池与 TCP 超时处理的最佳实践

package main

import (
    "fmt"
    "log"
    "time"

    "gopkg.in/mgo.v2"
)

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

func init() {
    // Define Mgo DialInfo with custom timeouts
    dialInfo := &mgo.DialInfo{
        Addrs:    []string{"localhost:27017"}, // MongoDB server address
        Timeout:  10 * time.Second,            // Dial timeout (initial connection)
        Database: "mydb",                      // Optional: default database
        Username: "myuser",                    // Optional: username
        Password: "mypassword",                // Optional: password
    }

    // Establish the master session
    var err error
    globalSession, err = mgo.DialWithInfo(dialInfo)
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }

    // Set a socket timeout for the master session (applies to all copies by default)
    // This timeout applies to individual read/write operations on the socket.
    globalSession.SetSocketTimeout(30 * time.Second) // Set socket timeout to 30 seconds

    // Optional: Set a sync timeout for write operations requiring acknowledgement
    // globalSession.SetSyncTimeout(15 * time.Second)

    // Set mode to Monotonic for read consistency in replica sets
    globalSession.SetMode(mgo.Monotonic, true)

    fmt.Println("MongoDB master session initialized successfully.")
}

// GetSession returns a copy of the master session
func GetSession() *mgo.Session {
    return globalSession.Copy()
}

func main() {
    // Example usage in a request handler or background job
    session := GetSession()
    defer session.Close() // Always close session copies!

    c := session.DB("mydb").C("mycollection")

    // Example: Insert a document
    err := c.Insert(map[string]string{"name": "Test Document", "status": "active"})
    if err != nil {
        if mgo.Is );
    }
}

package main

import (
    "fmt"
    "log"
    "time"

    "gopkg.in/mgo.v2"
)

var masterSession *mgo.Session

func init() {
    // Assume masterSession is initialized as in the previous example
    dialInfo := &mgo.DialInfo{
        Addrs:   []string{"localhost:27017"},
        Timeout: 10 * time.Second,
    }
    var err error
    masterSession, err = mgo.DialWithInfo(dialInfo)
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }
    masterSession.SetSocketTimeout(30 * time.Second)
    masterSession.SetMode(mgo.Monotonic, true)
    fmt.Println("Master session initialized.")
}

// performDBOperation safely performs a database operation, handling potential session errors.
func performDBOperation(operation func(*mgo.Collection) error) error {
    session := masterSession.Copy()
    defer session.Close() // Ensure session is closed

    c := session.DB("mydb").C("mycollection")

    err := operation(c)
    if err != nil {
        // Check for specific Mgo errors indicating a bad session/connection
        if mgo.Is (err) || mgo.Is (err) {
            log.Printf("Session error detected: %v. Attempting to refresh session...", err)
            // Option 1: Try to refresh the session (less aggressive)
            // session.Refresh() // Refresh might not be enough for TCP timeouts

            // Option 2: Re-copy a new session from the master (more robust)
            // For a single operation, simply returning the error and letting the caller get a new session is common.
            // If this were a long-lived session in a specific context, one might try to re-copy here.
            // For web requests, usually the current request fails, and the next request gets a fresh session.
            return fmt.Errorf("database session became invalid, please retry: %w", err)
        }
        return err // Other errors
    }
    return nil
}

func main() {
    // Example usage
    err := performDBOperation(func(c *mgo.Collection) error {
        // Simulate a slow query or timeout scenario
        // For actual timeout, you'd see "read tcp ... i/o timeout"
        return c.Insert(map[string]string{"data": fmt.Sprintf("value-%d", time.Now().UnixNano())})
    })

    if err != nil {
        fmt.Printf("Operation failed: %v\n", err)
        // If the error indicates a session issue, subsequent requests will automatically get a new session.
    } else {
        fmt.Println("Operation successful.")
    }

    // It's crucial to ensure the master session is closed when the application shuts down
    // In a real application, this would be handled by a graceful shutdown mechanism.
    defer masterSession.Close()
}