vendor/github.com/gorilla/websocket/examples/echo/client.go

   1 // Copyright 2015 The Gorilla WebSocket Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build ignore
   6
   7 package main
   8
   9 import (
  10         "flag"
  11         "log"
  12         "net/url"
  13         "os"
  14         "os/signal"
  15         "time"
  16
  17         "github.com/gorilla/websocket"
  18 )
  19
  20 var addr = flag.String("addr", "localhost:8080", "http service address")
  21
  22 func main() {
  23         flag.Parse()
  24         log.SetFlags(0)
  25
  26         interrupt := make(chan os.Signal, 1)
  27         signal.Notify(interrupt, os.Interrupt)
  28
  29         u := url.URL{Scheme: "ws", Host: *addr, Path: "/echo"}
  30         log.Printf("connecting to %s", u.String())
  31
  32         c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
  33         if err != nil {
  34                 log.Fatal("dial:", err)
  35         }
  36         defer c.Close()
  37
  38         done := make(chan struct{})
  39
  40         go func() {
  41                 defer close(done)
  42                 for {
  43                         _, message, err := c.ReadMessage()
  44                         if err != nil {
  45                                 log.Println("read:", err)
  46                                 return
  47                         }
  48                         log.Printf("recv: %s", message)
  49                 }
  50         }()
  51
  52         ticker := time.NewTicker(time.Second)
  53         defer ticker.Stop()
  54
  55         for {
  56                 select {
  57                 case <-done:
  58                         return
  59                 case t := <-ticker.C:
  60                         err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))
  61                         if err != nil {
  62                                 log.Println("write:", err)
  63                                 return
  64                         }
  65                 case <-interrupt:
  66                         log.Println("interrupt")
  67
  68                         // Cleanly close the connection by sending a close message and then
  69                         // waiting (with timeout) for the server to close the connection.
  70                         err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
  71                         if err != nil {
  72                                 log.Println("write close:", err)
  73                                 return
  74                         }
  75                         select {
  76                         case <-done:
  77                         case <-time.After(time.Second):
  78                         }
  79                         return
  80                 }
  81         }
  82 }