title: Gorilla Websocket not receiving message
body: <p>I am building a gateway in Golang that communicates with Gorilla websockets.</p>
  
  <p>I am running it on Ubuntu 16.04, and testing it currently with a .NET console app.</p>
  
  <p>Using Wireshark on Windows and sniffit on Ubuntu have determined that <em>messages are being sent correctly from the Windows client and received by the Ubuntu box</em>.</p>
  
  <p>In my code, however, sometimes after a few successful messages, and sometimes after none, my gateway is failing to read the message (still sitting at <code>_, msg, errCon := conn.ReadMessage()</code>)</p>
  
  <p>An example of the output will be:</p>
  
  <blockquote>
    <p>2018/03/27 02:38:06 Awaiting Message ... 
    2018/03/27 02:38:07 Message received: main.AdminRequest{Data:"{\"SomeDataHeader\":\"SomeData\"}",
    Requestor:"user", Type:"JustDoSomethingRequest", Ukey:"talca"} 2018/03/27 02:38:07
    {"SomeDataHeader":"SomeData"} 
    2018/03/27 02:38:07 Awaiting Message ...</p>
  </blockquote>
  
  <p>As I have previously said, it may receive a few messages like this, but, despite network traffic on both ends continuing, no more messages will be received</p>
  
  <p>I am fairly new with Golang, and working under the assumption that I am missing something.</p>
  
  <p><strike>I have trimmed out error handling and the like for the sake of brevity in the code below, but this is an example of the failing code.</strike></p>
  
  <p><strong>EDIT</strong> As requested I have added Golang full code, and C# client code below (although, as I stated, Wireshark and sniffit have determined that data is going over the wire)</p>
  
  <pre><code>package main
  
  import (
      "fmt"
      "net/http"
      "github.com/gorilla/websocket"
      "encoding/json"
      "log"
  )
  
  var upgrader = websocket.Upgrader{ ReadBufferSize:  1024, WriteBufferSize: 1024,
      CheckOrigin: func(r *http.Request) bool {
          return true
      },
  }
  
  type AdminRequest struct {
          Data      string `json:"Data"`
          Requestor string `json:"Requestor"`
          Type      string `json:"Type"`
          Ukey      string `json:"Ukey"`
      } 
  
  func main() {
  
      http.HandleFunc("/a", func(w http.ResponseWriter, r *http.Request) {
          var conn, _ = upgrader.Upgrade(w, r, nil)
  
          go func(conn *websocket.Conn) {
              for {
                  _, _, err := conn.ReadMessage()
                  if err != nil {         
                      log.Println("Close: "+ err.Error())
                      conn.Close()
                      return
                  }
              }
          }(conn)
  
  
          go func(conn *websocket.Conn) {
              for {
  
                  log.Println("Awaiting Message ...")
                  _, msg, errCon := conn.ReadMessage()
  
                  if errCon != nil {
                      log.Println("Read Error:", errCon)
                      break
                  }
  
                  log.Println("Message received: ")
  
                  var r AdminRequest
  
                  if err := json.Unmarshal(msg, &amp;r); err != nil {
  
                      log.Println("Error: " + err.Error());
                      return;
                  }
  
                  fmt.Printf("%#v\n", r)
                  log.Println(r.Data);
              }           
          }(conn)
  
      })
  
      http.ListenAndServe(":3000", nil)
  }
  </code></pre>
  
  <p>C# Code:</p>
  
  <pre><code>public class Client : IDisposable
      {
          private ClientWebSocket _socket;
  
  
          string _address;
          int _port;
          public Client(string address)
          {
              _address = address;
  
              _socket = new ClientWebSocket();
          }
  
          public async void SetupForReceivingStuffs()
          {
              while (_socket.State == WebSocketState.Open)
              {
                  ArraySegment&lt;byte&gt; receivedBytes = new ArraySegment&lt;byte&gt;(new byte[1024]);
                  WebSocketReceiveResult result = await _socket.ReceiveAsync(receivedBytes, CancellationToken.None);
  
                  Console.WriteLine(Encoding.UTF8.GetString(receivedBytes.Array, 0, result.Count));
              }
          }
  
          public async void SetupForSendingStuffs(ConcurrentQueue&lt;AdminRequest&gt; queue)
          {
              while (_socket.State == WebSocketState.Open)
              {
                  AdminRequest next;
  
                  while (queue.Count &gt; 0)
                  {
                      if (queue.TryDequeue(out next))
                      {
                          await Send(next);
                      }
                  }
  
                  await Task.Yield();
              }
          }
  
          public async Task Connect()
          {
              while (_socket.State != WebSocketState.Open)
              {
                  try
                  {
                      _socket = new ClientWebSocket();
                      await _socket.ConnectAsync(new Uri(_address), CancellationToken.None);
  
                      Console.WriteLine("Socket state: " + _socket.State);
                  }
                  catch (Exception ex)
                  {
                      //Not getting hit
                      Console.WriteLine(ex.Message);
                      Console.WriteLine(ex.StackTrace);
                  }
              }
          }
  
  
  
          public Task Send&lt;TData&gt;(TData data)
          {
              string text = JsonConvert.SerializeObject(data);
  
              var encoded = Encoding.UTF8.GetBytes(text);
              var buffer = new ArraySegment&lt;Byte&gt;(encoded, 0, encoded.Length);
  
              return _socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
          }
  
  
          public void Dispose()
          {
              _socket.Dispose();
          }
      }
  </code></pre>
  
  <p>Called by:</p>
  
  <pre><code>class Program
  {
      static ConcurrentQueue&lt;AdminRequest&gt; _toSend;
  
      static void Main(string[] args)
      {
          _toSend = new ConcurrentQueue&lt;AdminRequest&gt;();
  
          Client client = new Client("ws:/(myip):(myport)/a");
          client.Connect().Wait();
  
          //client.SetupForReceivingStuffs();
          client.SetupForSendingStuffs(_toSend);
  
          WriteInstructions();
  
          LoopAuto();
  
          Console.WriteLine("Bye");
      }
  
      private static void LoopAuto()
      {
          DateTime nextMessage = DateTime.Now;
  
          while (true)
          {
  
              if (DateTime.Now &lt; nextMessage) continue;
              Console.WriteLine("Next");
              nextMessage = DateTime.Now.AddSeconds(2);
  
              _toSend.Enqueue(new AdminRequest
              {
                  Data = "{\"SomeDataHeader\":\"SomeData\"}",
                  Requestor = "user",
                  Type = "JustDoSomethingRequest",
                  Ukey = "talca"
              });
          }
      }
  
      private static ConsoleKeyInfo LoopManual()
      {
          ConsoleKeyInfo info;
          do
          {
              info = Console.ReadKey(true);
  
              if (info.KeyChar == '1')
              {
                  _toSend.Enqueue(new AdminRequest
                  {
                      Data = "{\"SomeDataHeader\":\"SomeData\"}",
                      Requestor = "user",
                      Type = "JustDoSomethingRequest",
                      Ukey = "talca"
                  });
              }
              else if (info.KeyChar == 'i')
              {
                  WriteInstructions();
              }
  
          } while (info.KeyChar != 'x');
  
          return info;
      }
  
      private static void WriteInstructions()
      {
          Console.WriteLine("1. Send New Message");
          Console.WriteLine("i. Instructions (these lines)");
          Console.WriteLine("x: Exit");
      }
  }
  </code></pre>