example_test.go

Documentation: nhooyr.io/websocket

     1  package websocket_test
     2  
     3  import (
     4  	"context"
     5  	"log"
     6  	"net/http"
     7  	"time"
     8  
     9  	"nhooyr.io/websocket"
    10  	"nhooyr.io/websocket/wsjson"
    11  )
    12  
    13  func ExampleAccept() {
    14  	// This handler accepts a WebSocket connection, reads a single JSON
    15  	// message from the client and then closes the connection.
    16  
    17  	fn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    18  		c, err := websocket.Accept(w, r, nil)
    19  		if err != nil {
    20  			log.Println(err)
    21  			return
    22  		}
    23  		defer c.CloseNow()
    24  
    25  		ctx, cancel := context.WithTimeout(r.Context(), time.Second*10)
    26  		defer cancel()
    27  
    28  		var v interface{}
    29  		err = wsjson.Read(ctx, c, &v)
    30  		if err != nil {
    31  			log.Println(err)
    32  			return
    33  		}
    34  
    35  		c.Close(websocket.StatusNormalClosure, "")
    36  	})
    37  
    38  	err := http.ListenAndServe("localhost:8080", fn)
    39  	log.Fatal(err)
    40  }
    41  
    42  func ExampleDial() {
    43  	// Dials a server, writes a single JSON message and then
    44  	// closes the connection.
    45  
    46  	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
    47  	defer cancel()
    48  
    49  	c, _, err := websocket.Dial(ctx, "ws://localhost:8080", nil)
    50  	if err != nil {
    51  		log.Fatal(err)
    52  	}
    53  	defer c.CloseNow()
    54  
    55  	err = wsjson.Write(ctx, c, "hi")
    56  	if err != nil {
    57  		log.Fatal(err)
    58  	}
    59  
    60  	c.Close(websocket.StatusNormalClosure, "")
    61  }
    62  
    63  func ExampleCloseStatus() {
    64  	// Dials a server and then expects to be disconnected with status code
    65  	// websocket.StatusNormalClosure.
    66  
    67  	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
    68  	defer cancel()
    69  
    70  	c, _, err := websocket.Dial(ctx, "ws://localhost:8080", nil)
    71  	if err != nil {
    72  		log.Fatal(err)
    73  	}
    74  	defer c.CloseNow()
    75  
    76  	_, _, err = c.Reader(ctx)
    77  	if websocket.CloseStatus(err) != websocket.StatusNormalClosure {
    78  		log.Fatalf("expected to be disconnected with StatusNormalClosure but got: %v", err)
    79  	}
    80  }
    81  
    82  func Example_writeOnly() {
    83  	// This handler demonstrates how to correctly handle a write only WebSocket connection.
    84  	// i.e you only expect to write messages and do not expect to read any messages.
    85  	fn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    86  		c, err := websocket.Accept(w, r, nil)
    87  		if err != nil {
    88  			log.Println(err)
    89  			return
    90  		}
    91  		defer c.CloseNow()
    92  
    93  		ctx, cancel := context.WithTimeout(r.Context(), time.Minute*10)
    94  		defer cancel()
    95  
    96  		ctx = c.CloseRead(ctx)
    97  
    98  		t := time.NewTicker(time.Second * 30)
    99  		defer t.Stop()
   100  
   101  		for {
   102  			select {
   103  			case <-ctx.Done():
   104  				c.Close(websocket.StatusNormalClosure, "")
   105  				return
   106  			case <-t.C:
   107  				err = wsjson.Write(ctx, c, "hi")
   108  				if err != nil {
   109  					log.Println(err)
   110  					return
   111  				}
   112  			}
   113  		}
   114  	})
   115  
   116  	err := http.ListenAndServe("localhost:8080", fn)
   117  	log.Fatal(err)
   118  }
   119  
   120  func Example_crossOrigin() {
   121  	// This handler demonstrates how to safely accept cross origin WebSockets
   122  	// from the origin example.com.
   123  	fn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   124  		c, err := websocket.Accept(w, r, &websocket.AcceptOptions{
   125  			OriginPatterns: []string{"example.com"},
   126  		})
   127  		if err != nil {
   128  			log.Println(err)
   129  			return
   130  		}
   131  		c.Close(websocket.StatusNormalClosure, "cross origin WebSocket accepted")
   132  	})
   133  
   134  	err := http.ListenAndServe("localhost:8080", fn)
   135  	log.Fatal(err)
   136  }
   137  
   138  func ExampleConn_Ping() {
   139  	// Dials a server and pings it 5 times.
   140  
   141  	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
   142  	defer cancel()
   143  
   144  	c, _, err := websocket.Dial(ctx, "ws://localhost:8080", nil)
   145  	if err != nil {
   146  		log.Fatal(err)
   147  	}
   148  	defer c.CloseNow()
   149  
   150  	// Required to read the Pongs from the server.
   151  	ctx = c.CloseRead(ctx)
   152  
   153  	for i := 0; i < 5; i++ {
   154  		err = c.Ping(ctx)
   155  		if err != nil {
   156  			log.Fatal(err)
   157  		}
   158  	}
   159  
   160  	c.Close(websocket.StatusNormalClosure, "")
   161  }
   162  
   163  // This example demonstrates full stack chat with an automated test.
   164  func Example_fullStackChat() {
   165  	// https://github.com/nhooyr/websocket/tree/master/internal/examples/chat
   166  }
   167  
   168  // This example demonstrates a echo server.
   169  func Example_echo() {
   170  	// https://github.com/nhooyr/websocket/tree/master/internal/examples/echo
   171  }
   172
View as plain text