### JavaScript WebSocket Client for Real-time Chat

Source: https://github.com/gorilla/websocket/blob/main/examples/command/home.html

This JavaScript code implements a WebSocket client to connect to a server, send messages, and display received messages in real-time. It handles connection opening, closing, and message reception. It also includes basic error handling for browsers that do not support WebSockets.

```javascript
window.onload = function () {
    var conn;
    var msg = document.getElementById("msg");
    var log = document.getElementById("log");

    function appendLog(item) {
        var doScroll = log.scrollTop > log.scrollHeight - log.clientHeight - 1;
        log.appendChild(item);
        if (doScroll) {
            log.scrollTop = log.scrollHeight - log.clientHeight;
        }
    }

    document.getElementById("form").onsubmit = function () {
        if (!conn) {
            return false;
        }
        if (!msg.value) {
            return false;
        }
        conn.send(msg.value);
        msg.value = "";
        return false;
    };

    if (window["WebSocket"]) {
        conn = new WebSocket("ws://" + document.location.host + "/ws");
        conn.onclose = function (evt) {
            var item = document.createElement("div");
            item.innerHTML = "<b>Connection closed.</b>";
            appendLog(item);
        };
        conn.onmessage = function (evt) {
            var messages = evt.data.split('\n');
            for (var i = 0; i < messages.length; i++) {
                var item = document.createElement("div");
                item.innerText = messages[i];
                appendLog(item);
            }
        };
    } else {
        var item = document.createElement("div");
        item.innerHTML = "<b>Your browser does not support WebSockets.</b>";
        appendLog(item);
    }
};
```

--------------------------------

### Go: Upgrade HTTP to WebSocket Server

Source: https://context7.com/gorilla/websocket/llms.txt

Sets up a WebSocket server in Go that upgrades incoming HTTP connections. It utilizes the `websocket.Upgrader` for configuration, including buffer sizes and origin checking. The server accepts WebSocket messages, logs them, and echoes them back to the client.

```go
package main

import (
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    CheckOrigin: func(r *http.Request) bool {
        // Allow connections from any origin (adjust for production)
        return true
    },
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Printf("upgrade failed: %v", err)
        return
    }
    defer conn.Close()

    log.Printf("client connected from %v", conn.RemoteAddr())

    // Handle messages
    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
                log.Printf("error: %v", err)
            }
            break
        }
        log.Printf("received: %s", message)

        // Echo message back
        if err := conn.WriteMessage(messageType, message); err != nil {
            log.Printf("write error: %v", err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### Custom WebSocket Client Dialer in Go

Source: https://context7.com/gorilla/websocket/llms.txt

This Go code demonstrates creating a WebSocket client with a custom dialer from the gorilla/websocket library. It allows for advanced configuration options such as handshake timeouts, buffer sizes, compression, subprotocols, TLS settings (including skipping verification and minimum TLS version), and proxy support from environment variables. It also shows how to add custom headers for authentication and other metadata.

```go
package main

import (
    "crypto/tls"
    "log"
    "net/http"
    "net/url"
    "time"
    "github.com/gorilla/websocket"
)

func main() {
    // Custom dialer with advanced configuration
    dialer := &websocket.Dialer{
        HandshakeTimeout: 10 * time.Second,
        ReadBufferSize:   8192,
        WriteBufferSize:  8192,
        EnableCompression: true,
        Subprotocols:     []string{"chat", "superchat"},
        TLSClientConfig: &tls.Config{
            InsecureSkipVerify: false,
            MinVersion:         tls.VersionTLS12,
        },
        Proxy: http.ProxyFromEnvironment,
    }

    // Custom headers for authentication
    headers := http.Header{}
    headers.Add("Authorization", "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9")
    headers.Add("X-Client-Version", "1.0.0")
    headers.Add("User-Agent", "CustomWebSocketClient/1.0")

    u := url.URL{Scheme: "wss", Host: "example.com", Path: "/ws"}
    log.Printf("connecting to %s", u.String())

    conn, resp, err := dialer.Dial(u.String(), headers)
    if err != nil {
        log.Fatalf("dial error: %v, status: %v", err, resp)
    }
    defer conn.Close()

    log.Printf("connected, subprotocol: %s", conn.Subprotocol())
    log.Printf("local addr: %v, remote addr: %v",
        conn.LocalAddr(), conn.RemoteAddr())

    // Set connection limits
    conn.SetReadLimit(1024 * 1024) // 1MB
    conn.SetReadDeadline(time.Now().Add(30 * time.Second))

    // Send initial message
    if err := conn.WriteMessage(websocket.TextMessage, 
        []byte("Hello from custom client")); err != nil {
        log.Fatalf("write error: %v", err)
    }

    // Read response
    messageType, message, err := conn.ReadMessage()
    if err != nil {
        log.Fatalf("read error: %v", err)
    }

    log.Printf("received: type=%d, message=%s", messageType, message)

    // Graceful close
    closeMsg := websocket.FormatCloseMessage(websocket.CloseNormalClosure, 
        "client shutting down")
    conn.WriteMessage(websocket.CloseMessage, closeMsg)
    time.Sleep(time.Second) // Wait for close handshake
}

```

--------------------------------

### Go: Connect to WebSocket Server as Client

Source: https://context7.com/gorilla/websocket/llms.txt

Implements a WebSocket client in Go to connect to a specified server address. It includes graceful shutdown handling using OS signals and periodic message sending. The client reads messages from the server in a separate goroutine and manages connection lifecycle with timeouts.

```go
package main

import (
    "log"
    "net/url"
    "os"
    "os/signal"
    "time"
    "github.com/gorilla/websocket"
)

func main() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt)

    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/ws"}
    log.Printf("connecting to %s", u.String())

    conn, resp, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatalf("dial failed: %v, response: %v", err, resp)
    }
    defer conn.Close()

    done := make(chan struct{})

    // Read messages in separate goroutine
    go func() {
        defer close(done)
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                log.Printf("read error: %v", err)
                return
            }
            log.Printf("received: %s", message)
        }
    }()

    // Send messages periodically
    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-done:
            return
        case <-ticker.C:
            message := []byte("Hello from client")
            if err := conn.WriteMessage(websocket.TextMessage, message); err != nil {
                log.Printf("write error: %v", err)
                return
            }
        case <-interrupt:
            log.Println("shutting down gracefully")
            err := conn.WriteMessage(websocket.CloseMessage,
                websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
            if err != nil {
                log.Printf("close error: %v", err)
            }
            select {
            case <-done:
            case <-time.After(time.Second):
            }
            return
        }
    }
}
```

--------------------------------

### Enable Per-Message Deflate Compression in Go WebSocket Server

Source: https://context7.com/gorilla/websocket/llms.txt

This Go code enables and configures per-message deflate compression for a WebSocket server. It uses the gorilla/websocket library and the standard flate compression package. The server can set compression levels and enable compression for outgoing messages, reducing bandwidth usage. It handles upgrading HTTP requests, reading messages, and writing compressed responses.

```go
package main

import (
    "compress/flate"
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:    4096,
    WriteBufferSize:   4096,
    EnableCompression: true, // Enable compression negotiation
}

func handleCompression(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Printf("upgrade error: %v", err)
        return
    }
    defer conn.Close()

    // Set compression level (flate.BestSpeed to flate.BestCompression)
    if err := conn.SetCompressionLevel(flate.BestSpeed); err != nil {
        log.Printf("compression level error: %v", err)
        return
    }

    // Enable compression for outgoing messages
    conn.EnableWriteCompression(true)

    log.Println("compression enabled, waiting for messages")

    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
                log.Printf("error: %v", err)
            }
            break
        }

        log.Printf("received compressed message: %d bytes", len(message))

        // Large payload that benefits from compression
        response := make([]byte, len(message)*2)
        copy(response, message)
        copy(response[len(message):], message)

        // Write with compression
        if err := conn.WriteMessage(messageType, response); err != nil {
            log.Printf("write error: %v", err)
            break
        }

        log.Printf("sent compressed response: %d bytes", len(response))
    }
}

func main() {
    http.HandleFunc("/compress", handleCompression)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

```

--------------------------------

### Stream Messages with NextWriter/NextReader in Go

Source: https://context7.com/gorilla/websocket/llms.txt

This Go code illustrates efficient handling of large WebSocket messages using the NextWriter and NextReader interfaces from the Gorilla WebSocket library. It avoids loading entire messages into memory by streaming data directly from the reader to the writer, suitable for real-time data pipelines. It requires the 'net/http', 'io', and 'github.com/gorilla/websocket' packages.

```go
package main

import (
    "io"
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

func handleStreaming(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Printf("upgrade error: %v", err)
        return
    }
    defer conn.Close()

    for {
        // Get reader for incoming message
        messageType, reader, err := conn.NextReader()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
                log.Printf("read error: %v", err)
            }
            break
        }

        log.Printf("receiving message type: %d", messageType)

        // Get writer for outgoing message
        writer, err := conn.NextWriter(messageType)
        if err != nil {
            log.Printf("writer error: %v", err)
            break
        }

        // Stream data directly from reader to writer
        bytesCopied, err := io.Copy(writer, reader)
        if err != nil {
            log.Printf("copy error: %v", err)
            writer.Close()
            break
        }

        log.Printf("echoed %d bytes", bytesCopied)

        // Close writer to flush the message
        if err := writer.Close(); err != nil {
            log.Printf("close writer error: %v", err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/stream", handleStreaming)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

```

--------------------------------

### Configure Read Limits and Timeouts with Gorilla WebSocket in Go

Source: https://context7.com/gorilla/websocket/llms.txt

This Go code snippet demonstrates how to configure connection limits and deadlines for WebSocket connections using the Gorilla WebSocket library. It sets read buffer sizes, handshake timeouts, read deadlines, and pong handlers to manage slow clients and prevent resource exhaustion. Dependencies include 'log', 'net/http', 'time', and 'github.com/gorilla/websocket'. It handles incoming messages and sends periodic ping messages to maintain the connection.

```go
package main

import (
    "log"
    "net/http"
    "time"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    HandshakeTimeout: 10 * time.Second,
    ReadBufferSize:   4096,
    WriteBufferSize:  4096,
}

func handleWithLimits(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Printf("upgrade error: %v", err)
        return
    }
    defer conn.Close()

    // Set maximum message size to 512KB
    conn.SetReadLimit(512 * 1024)

    // Set read deadline - connection must receive pong within this time
    conn.SetReadDeadline(time.Now().Add(60 * time.Second))

    // Configure ping handler to update read deadline
    conn.SetPongHandler(func(string) error {
        conn.SetReadDeadline(time.Now().Add(60 * time.Second))
        return nil
    })

    // Set write deadline for each write operation
    conn.SetWriteDeadline(time.Now().Add(10 * time.Second))

    // Start ping ticker to keep connection alive
    ticker := time.NewTicker(30 * time.Second)
    defer ticker.Stop()

    done := make(chan struct{})

    go func() {
        defer close(done)
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
                    log.Printf("read error: %v", err)
                }
                return
            }
            log.Printf("received: %s", message)
        }
    }()

    for {
        select {
        case <-ticker.C:
            conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
            if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
                log.Printf("ping error: %v", err)
                return
            }
        case <-done:
            return
        }
    }
}

func main() {
    http.HandleFunc("/limits", handleWithLimits)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

```

--------------------------------

### Implement Custom Ping/Pong Handlers in Go

Source: https://context7.com/gorilla/websocket/llms.txt

This Go code demonstrates how to implement custom handlers for ping, pong, and close control messages in WebSocket connections. It allows for application-specific logic when these messages are received or sent, including heartbeats and connection closure procedures. Dependencies include the 'net/http' and 'github.com/gorilla/websocket' packages.

```go
package main

import (
    "log"
    "net/http"
    "time"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

func handleWithCustomHandlers(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Printf("upgrade error: %v", err)
        return
    }
    defer conn.Close()

    lastPong := time.Now()

    // Custom pong handler
    conn.SetPongHandler(func(appData string) error {
        lastPong = time.Now()
        log.Printf("received pong with data: %s", appData)
        return nil
    })

    // Custom ping handler
    conn.SetPingHandler(func(appData string) error {
        log.Printf("received ping with data: %s", appData)
        // Send pong with same application data
        err := conn.WriteControl(websocket.PongMessage, []byte(appData),
            time.Now().Add(time.Second))
        if err != nil {
            log.Printf("pong write error: %v", err)
        }
        return nil
    })

    // Custom close handler
    conn.SetCloseHandler(func(code int, text string) error {
        log.Printf("received close: code=%d, text=%s", code, text)
        message := websocket.FormatCloseMessage(code, "")
        conn.WriteControl(websocket.CloseMessage, message,
            time.Now().Add(time.Second))
        return nil
    })

    ticker := time.NewTicker(15 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            // Check if last pong is too old
            if time.Since(lastPong) > 45*time.Second {
                log.Println("client unresponsive, closing connection")
                return
            }
            // Send ping with timestamp
            pingData := []byte(time.Now().Format(time.RFC3339))
            if err := conn.WriteControl(websocket.PingMessage, pingData,
                time.Now().Add(time.Second)); err != nil {
                log.Printf("ping error: %v", err)
                return
            }
        default:
            _, _, err := conn.ReadMessage()
            if err != nil {
                return
            }
        }
    }
}

func main() {
    http.HandleFunc("/custom", handleWithCustomHandlers)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

```

--------------------------------

### Handle JSON Messages with Gorilla WebSocket in Go

Source: https://context7.com/gorilla/websocket/llms.txt

This Go code snippet demonstrates how to send and receive JSON-encoded messages using the Gorilla WebSocket library. It includes automatic marshaling and unmarshaling of custom message structs and handles connection upgrades. Dependencies include the standard library's 'log', 'net/http', 'time', and the 'github.com/gorilla/websocket' package. It expects incoming JSON messages conforming to the 'Message' struct and sends back a JSON response.

```go
package main

import (
    "log"
    "net/http"
    "time"
    "github.com/gorilla/websocket"
)

type Message struct {
    Type      string    `json:"type"`
    Content   string    `json:"content"`
    Timestamp time.Time `json:"timestamp"`
    UserID    string    `json:"user_id"`
}

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool { return true },
}

func handleJSON(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Printf("upgrade error: %v", err)
        return
    }
    defer conn.Close()

    for {
        var msg Message

        // Read JSON message
        if err := conn.ReadJSON(&msg); err != nil {
            if websocket.IsCloseError(err, websocket.CloseNormalClosure) {
                log.Println("connection closed normally")
            } else {
                log.Printf("read json error: %v", err)
            }
            break
        }

        log.Printf("received: type=%s, content=%s, user=%s",
            msg.Type, msg.Content, msg.UserID)

        // Send JSON response
        response := Message{
            Type:      "response",
            Content:   "Message received: " + msg.Content,
            Timestamp: time.Now(),
            UserID:    "server",
        }

        if err := conn.WriteJSON(response); err != nil {
            log.Printf("write json error: %v", err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/json", handleJSON)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.