func webSocket(res http.ResponseWriter, req *http.Request) {
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: func(r *http.Request) bool { return true },
}
res.Header().Set("Access-Control-Allow-Origin", "*")
conn, err := upgrader.Upgrade(res, req, nil)
if err != nil {
log.Printf("Not a web socket connection: %s \n", err)
return
}
for {
messageType, p, err := conn.ReadMessage()
if err != nil {
return
}
if err = conn.WriteMessage(messageType, p); err != nil {
return
}
}
}
func slashws(w http.ResponseWriter, req *http.Request) {
// Upgrader.Upgrade() has Origin check if .CheckOrigin is nil
upgrader := gorillawebsocket.Upgrader{}
wsconn, err := upgrader.Upgrade(w, req, nil)
if err != nil { // Upgrade() does http.Error() to the client
return
}
// req.Method == "GET" asserted by the mux
req.Form = nil // reset reused later .Form
c := &conn{
Conn: wsconn,
requestOrigin: req,
receive: make(chan *received, 2),
push: make(chan *pageUpdate, 2),
full: defaultClient(),
}
register <- c
defer func() {
unregister <- c
c.Conn.Close()
}()
stop := make(chan struct{}, 1)
go c.receiveLoop(stop) // read from the client
c.updateLoop(stop) // write to the client
}
func IndexWS(access *Access, errlog *log.Logger, minperiod flags.Period, w http.ResponseWriter, req *http.Request) {
// Upgrader.Upgrade() has Origin check if .CheckOrigin is nil
upgrader := gorillawebsocket.Upgrader{
HandshakeTimeout: 5 * time.Second,
}
wsconn, err := upgrader.Upgrade(w, req, nil)
if err != nil { // Upgrade() does http.Error() to the client
return
}
// req.Method == "GET" asserted by the mux
req.Form = nil // reset reused later .Form
c := &conn{
Conn: wsconn,
requestOrigin: req,
receive: make(chan *received, 2),
pushch: make(chan *IndexUpdate, 2),
para: params.NewParams(minperiod),
access: access,
}
Register <- c
defer func() {
unregister <- c
c.Conn.Close()
}()
stop := make(chan struct{}, 1)
go c.receiveLoop(stop) // read from the client
c.updateLoop(errlog, stop) // write to the client
}
func Upgrade(res http.ResponseWriter, req *http.Request) {
if req.Header["Origin"][0] != "http://localhost" {
return
}
up := websocket.Upgrader{
CheckOrigin: func(req *http.Request) bool {
if req.Header["Origin"][0] != "http://localhost" {
// return false
// gorilla stops the app if wrong origin...
}
return true
},
}
conn, err := up.Upgrade(res, req, nil)
if err != nil {
log.Fatal(err)
}
go hub.Handle(conn)
hub.H.Register <- &hub.Register{conn, time.Now().UnixNano()}
r, err := json.Marshal(&hub.BroadcastMessage{
0,
"User connected",
})
if err != nil {
log.Fatal(err)
}
hub.H.Broadcast <- &hub.Broadcast{
conn,
r,
"default",
}
}
// Start the websocket server, each peer connecting to this websocket will be added as a connection to the dispatcher
func Start(d *Dispatcher, port int) {
var upgrader = websocket.Upgrader{
ReadBufferSize: 2048,
WriteBufferSize: 2048,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
log.Debug("Connection received")
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Fatal(err)
}
defer conn.Close()
startConnection(conn, d)
})
go http.ListenAndServe(fmt.Sprintf(":%d", port), nil)
log.Println(fmt.Sprintf("Websocket server started on port %d", port))
select {}
}
func (w *webserver) live(resp http.ResponseWriter, req *http.Request) {
//get our feeder registered
wsf := &liveWSFeeder{
ch: make(chan namedBwSample, chanBufferSize),
}
id, err := w.lf.RegisterLiveFeeder(wsf)
if err != nil {
resp.WriteHeader(http.StatusInternalServerError)
return
}
defer w.lf.DeregisterLiveFeeder(id)
//upgrade to a websocket
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
conn, err := upgrader.Upgrade(resp, req, nil)
if err != nil {
return
}
defer conn.Close()
//start feeding and relaying
for s := range wsf.ch {
if err := websocket.WriteJSON(conn, s); err != nil {
break
}
}
}
func main() {
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
http.Handle("/", handlers.LoggingHandler(os.Stderr, http.FileServer(http.Dir("."))))
http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println(err)
return
}
defer conn.Close()
for {
t, msg, err := conn.ReadMessage()
if err != nil {
log.Println(err)
return
}
log.Println("Received:", string(msg))
err = conn.WriteMessage(t, msg)
if err != nil {
log.Println(err)
return
}
}
})
host := "localhost:3030"
log.Printf("http://%v", host)
log.Fatal(http.ListenAndServe(host, nil))
}
func consoleHandler(w http.ResponseWriter, r *http.Request) {
upgrader := websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println(err)
return
}
go wsReadLoop(conn)
defer conn.Close()
lines, done, err := tailFile(fOptions.LogPath)
if err != nil {
log.Println(err)
return
}
defer close(done)
for line := range lines {
err = conn.WriteMessage(websocket.TextMessage, append(line, '\n'))
if err != nil {
return
}
}
}
// ListenAndServe will run a simple WS (HTTP) server.
// return listening error
func (s *Server) ListenAndServe(address string, path string) error {
l, err := net.Listen("tcp", address)
if err != nil {
return err
}
s.listener = l
mux := http.NewServeMux()
mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
var upgrader = websocket.Upgrader{
ReadBufferSize: s.readBufferSize,
WriteBufferSize: s.writeBufferSize,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Print("upgrade:", err)
return
}
s.wsHandler.ServeWS(
conn.UnderlyingConn(),
newAbstractStream(conn),
r.URL.Query(),
)
})
s.httpHandler = mux
go s.serve()
return nil
}
func (ws *webSocketRenderer) handler(w http.ResponseWriter, r *http.Request) {
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
h := http.Header{}
h["Sec-WebSocket-Protocol"] = []string{"nesrender"}
conn, err := upgrader.Upgrade(w, r, h)
if err != nil {
panic("Unable to upgrade connection")
}
ws.conns = append(ws.conns, conn)
for {
t, _, err := conn.ReadMessage()
if err != nil {
break
}
if t == websocket.CloseMessage {
break
}
}
}
func startMockAcsServer(t *testing.T, closeWS <-chan bool) (*httptest.Server, chan<- string, <-chan string, <-chan error, error) {
serverChan := make(chan string)
requestsChan := make(chan string)
errChan := make(chan error)
upgrader := websocket.Upgrader{ReadBufferSize: 1024, WriteBufferSize: 1024}
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ws, err := upgrader.Upgrade(w, r, nil)
go func() {
<-closeWS
ws.Close()
}()
if err != nil {
errChan <- err
}
go func() {
_, msg, err := ws.ReadMessage()
if err != nil {
errChan <- err
} else {
requestsChan <- string(msg)
}
}()
for str := range serverChan {
err := ws.WriteMessage(websocket.TextMessage, []byte(str))
if err != nil {
errChan <- err
}
}
})
server := httptest.NewTLSServer(handler)
return server, serverChan, requestsChan, errChan, nil
}
func Handle(w http.ResponseWriter, r *http.Request) {
upgrader := websocket.Upgrader{
CheckOrigin: func(req *http.Request) bool {
if req.Host == "127.0.0.1:9090" {
return true
} else {
return false
}
},
}
var err error
WebSocketConn, err = upgrader.Upgrade(w, r, nil)
if err != nil {
utils.Errorf("Error upgrade http: %s", err.Error())
return
}
for {
mt, bytes, err := WebSocketConn.ReadMessage()
if err != nil {
utils.Errorf("Error read message: %v", err)
WebSocketConn.Close()
WebSocketConn = nil
return
}
utils.Debugf("Client msg received: %d, %s", mt, string(bytes))
}
}
func (f *FakeFirehose) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
f.lock.Lock()
defer f.lock.Unlock()
f.lastAuthorization = r.Header.Get("Authorization")
f.requested = true
if f.lastAuthorization != f.validToken {
log.Printf("Bad token passed to firehose: %s", f.lastAuthorization)
rw.WriteHeader(403)
r.Body.Close()
return
}
upgrader := websocket.Upgrader{
CheckOrigin: func(*http.Request) bool { return true },
}
ws, _ := upgrader.Upgrade(rw, r, nil)
defer ws.Close()
defer ws.WriteControl(websocket.CloseMessage, f.closeMessage, time.Time{})
for _, envelope := range f.events {
buffer, _ := proto.Marshal(&envelope)
err := ws.WriteMessage(websocket.BinaryMessage, buffer)
if err != nil {
panic(err)
}
}
f.wg.Wait()
}
func echo(w http.ResponseWriter, r *http.Request) {
// Upgrade from http to websocket protocol
upgrader := websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true
},
}
c, err := upgrader.Upgrade(w, r, nil)
if err != nil {
panic(err)
}
defer c.Close()
for {
mt, message, err := c.ReadMessage()
if err != nil {
panic(err)
}
fmt.Printf("Received message: %s\n", message)
err = c.WriteMessage(mt, message)
if err != nil {
panic(err)
}
}
}
func main() {
upgrader := websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
id, err := authentication.AuthenticateRequest(r.FormValue("AccessToken"))
if err != nil {
http.Error(w, err.Error(), 500)
return
}
if id == -1 {
http.Error(w, "", 401)
return
}
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Fatal(err)
}
c := client.New(id, conn)
router.AddClientChan <- c
go c.Run()
})
fmt.Println("listening on 8080")
http.ListenAndServe(":8080", nil)
}
func WSServer(w http.ResponseWriter, req *http.Request) {
var upgrader = websocket.Upgrader{
ReadBufferSize: 64,
WriteBufferSize: 64,
}
conn, err := upgrader.Upgrade(w, req, nil)
if err != nil {
fmt.Println("ERROR:" + err.Error())
return
}
for {
messageType, r, err := conn.NextReader()
reader := bufio.NewReader(r)
b, err := reader.ReadBytes('\n')
response := []byte("ECHO FROM " + servername + ":" + string(b))
if err != nil {
fmt.Println("ERROR:" + err.Error())
return
}
// w, err := conn.NextWriter(messageType)
// if err != nil {
// fmt.Println("ERROR:"+err.Error())
// return
// }
if err := conn.WriteMessage(messageType, response); err != nil {
fmt.Println("ERROR:" + err.Error())
return
}
}
}
func GetConnection(rw http.ResponseWriter, req *http.Request) (*connection, error) {
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
upgrader.CheckOrigin = func(r *http.Request) bool {
// allow all connections by default
return true
}
conn := &connection{}
for _, v := range req.Header["Connection"] {
for _, i := range strings.Split(v, ",") {
if strings.EqualFold(strings.TrimSpace(i), "upgrade") {
webConn, err := upgrader.Upgrade(rw, req, nil)
if err != nil {
return nil, err
}
conn.webConn = webConn
return conn, nil
}
}
}
conn.rw = rw
return conn, nil
}
func wsHandler(w http.ResponseWriter, r *http.Request) {
fmt.Println("wshandler")
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Print("upgrade:", err)
return
}
defer conn.Close()
if err != nil {
log.Println(err)
return
}
for {
messageType, message, err := conn.ReadMessage()
if err != nil {
return
}
log.Print(message)
err = conn.WriteMessage(messageType, []byte(strings.Join(getdrives(), ",")))
if err != nil {
return
}
}
}
func fakeFirehoseHandler(rw http.ResponseWriter, r *http.Request) {
defer GinkgoRecover()
authorization := r.Header.Get("Authorization")
if authorization != "bearer good-token" {
log.Printf("Bad token passed to firehose: %s", authorization)
rw.WriteHeader(403)
r.Body.Close()
return
}
upgrader := websocket.Upgrader{
CheckOrigin: func(*http.Request) bool { return true },
}
ws, _ := upgrader.Upgrade(rw, r, nil)
defer ws.Close()
defer ws.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""), time.Time{})
for envelope := range fakeFirehoseInputChan {
buffer, err := proto.Marshal(envelope)
Expect(err).NotTo(HaveOccurred())
err = ws.WriteMessage(websocket.BinaryMessage, buffer)
Expect(err).NotTo(HaveOccurred())
}
}
// NewSockets returns a new websocket port
func NewSockets(upgrader *websocket.Upgrader, headers http.Header, hs SocketHandler) FlatChains {
return NewFlatChain(func(c *Context, nx NextHandler) {
if headers != nil {
origin, ok := c.Req.Header["Origin"]
if ok {
headers.Set("Access-Control-Allow-Credentials", "true")
headers.Set("Access-Control-Allow-Origin", strings.Join(origin, ";"))
} else {
headers.Set("Access-Control-Allow-Origin", "*")
}
}
conn, err := upgrader.Upgrade(c.Res, c.Req, headers)
if err != nil {
return
}
flux.GoDefer(fmt.Sprintf("WebSocketPort.Handler"), func() {
hs(NewSocketWorker(&Websocket{
Conn: conn,
Ctx: c,
}))
nx(c)
})
})
}
func (t _websocket_example_handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
//ServeHTTP(ResponseWriter, *Request)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
wsConn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
fmt.Println(err)
return
}
go func() {
time.Sleep(100)
if err := wsConn.Close(); err != nil {
fmt.Printf("close error %s", err.Error())
return
}
}()
for i := 0; i < 11; i++ {
fmt.Printf("begin read count %d\n", i)
_, _, err := wsConn.ReadMessage()
if err != nil {
fmt.Println(err)
return
} else {
fmt.Printf("read count %d\n", i)
}
}
}
func main() {
prog := path.Base(os.Args[0])
log.SetFlags(0)
log.SetPrefix(prog + ": ")
flag.Usage = Usage
flag.Parse()
if flag.NArg() > 0 {
Usage()
os.Exit(1)
}
log.Printf("Serving at http://%s:%d/", *host, *port)
chat := Chat{}
chat.broadcast = topic.New()
chat.registry = birpc.NewRegistry()
chat.registry.RegisterService(&chat)
defer close(chat.broadcast.Broadcast)
upgrader := websocket.Upgrader{}
serve := func(w http.ResponseWriter, req *http.Request) {
ws, err := upgrader.Upgrade(w, req, nil)
if err != nil {
log.Println(err)
return
}
endpoint := wetsock.NewEndpoint(chat.registry, ws)
messages := make(chan interface{}, 10)
chat.broadcast.Register(messages)
go func() {
defer chat.broadcast.Unregister(messages)
for i := range messages {
msg := i.(Outgoing)
// Fire-and-forget.
// TODO use .Notify when it exists
_ = endpoint.Go("Chat.Message", msg, nil, nil)
}
// broadcast topic kicked us out for being too slow;
// probably a hung TCP connection. let client
// re-establish.
log.Printf("Kicking slow client: %v", ws.RemoteAddr())
ws.Close()
}()
if err := endpoint.Serve(); err != nil {
log.Printf("websocket error from %v: %v", ws.RemoteAddr(), err)
}
}
http.HandleFunc("/sock", serve)
http.Handle("/", http.HandlerFunc(index))
addr := fmt.Sprintf("%s:%d", *host, *port)
err := http.ListenAndServe(addr, nil)
if err != nil {
log.Fatal(err)
}
}
func (s *WSServer) serveMessages(w http.ResponseWriter, r *auth.AuthenticatedRequest) {
// if X-Host-ID specified avoid having twice the same ID
hostID := r.Header.Get("X-Host-ID")
if hostID != "" {
s.RLock()
for c := range s.clients {
if c.host == hostID {
logging.GetLogger().Errorf("host_id error, connection from %s(%s) conflicts with another one", r.RemoteAddr, hostID)
w.WriteHeader(http.StatusConflict)
s.RUnlock()
return
}
}
s.RUnlock()
}
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
conn, err := upgrader.Upgrade(w, &r.Request, nil)
if err != nil {
return
}
c := &WSClient{
read: make(chan []byte, maxMessages),
send: make(chan []byte, maxMessages),
conn: conn,
server: s,
host: hostID,
kind: r.Header.Get("X-Client-Type"),
}
logging.GetLogger().Infof("New WebSocket Connection from %s : URI path %s", conn.RemoteAddr().String(), r.URL.Path)
s.register <- c
var wg sync.WaitGroup
wg.Add(2)
quit := make(chan struct{})
go c.writePump(&wg, quit)
go c.processMessages(&wg, quit)
c.readPump()
quit <- struct{}{}
quit <- struct{}{}
close(c.read)
close(c.send)
wg.Wait()
}
// State opens up a push notification based state differential protocol. After
// a client connects to this endpoint, it will constantly receive state updates
// whenever a change occurs. The endpoint does not accept any inbound data apart
// from ping/pong messages to ensure the dashboard is still active.
func (server *stateServer) State(w http.ResponseWriter, r *http.Request) {
// Define the WebSocket protocol details and open the persistent connection
var upgrader = websocket.Upgrader{
ReadBufferSize: 65536,
WriteBufferSize: 65536,
}
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log15.Error("Failed to upgrade connection to web sockets", "error", err)
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
defer conn.Close()
// Create a contextual logger for this connection
session := atomic.AddUint32(&server.sessions, 1)
logger := log15.New("session", session)
logger.Debug("New dashboard connection")
defer logger.Debug("Dashboard connection closed")
// Lock the state for updates and stream out the current one
server.lock.Lock()
message, err := jsonMarshalLowercase(server.state)
if err != nil {
logger.Crit("Failed to serialize initial state", "error", err)
server.lock.Unlock()
return
}
if err := conn.WriteMessage(websocket.TextMessage, message); err != nil {
// Tear down the connection if initial send fails
logger.Warn("Failed to send initial state", "error", err)
server.lock.Unlock()
return
}
// Otherwise register the connection for update and ensure it's cleaned up
logger.Debug("Initial state sent, subscribing to diffs")
server.conns[session] = conn
defer func() {
server.lock.Lock()
defer server.lock.Unlock()
delete(server.conns, session)
}()
// Updates can proceed to all sessions
server.lock.Unlock()
// Keep reading messages until the client closes the connection
for {
// This is a push only endpoint, dump whatever the client sends
if _, _, err := conn.NextReader(); err != nil {
return
}
}
}
func main() {
flag.Parse()
go func() {
for {
err := SerialWaitSignal()
if err != nil {
log.Error(err)
continue
}
data, err := SerialReadFrame()
if err != nil {
log.Error(err)
continue
}
pm10 := bigEndian(data[0], data[1])
pm25 := bigEndian(data[2], data[3])
pm100 := bigEndian(data[4], data[5])
log.Infof("PM1.0: %d, PM2.5: %d, PM10: %d", pm10, pm25, pm100)
atomic.StoreInt32(¤tPM25, int32(pm25))
atomic.StoreInt32(¤tPM100, int32(pm100))
}
}()
router := httprouter.New()
k := kami.New(nil, router).With(CORS)
k.Get("/realtime", func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
upg := websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
// accept any origin
return true
},
}
ws, err := upg.Upgrade(w, r, nil)
if err != nil {
log.Warnf("Error to upgrade: %s", err.Error())
http.Error(w, "internal error", http.StatusInternalServerError)
return
}
go WSHandler(ws)
})
k.Get("/", func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/static/viewer.html", http.StatusMovedPermanently)
})
http.Handle("/", k.Handler())
fs := http.FileServer(http.Dir("static"))
http.Handle("/static/", http.StripPrefix("/static/", fs))
log.Infof("Listen at %s", *flagAPI)
panic(http.ListenAndServe(*flagAPI, http.DefaultServeMux))
}
//initServeSocket takes in a Broadcaster and initializes a serveSocket net/http
//handler function that upgrades the request to create a new WebSocket Conn,
//which then is used added to the Broadcaster.
func initServeSocket(b Broadcaster) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
up := ws.Upgrader{}
conn, err := up.Upgrade(w, r, nil)
if err != nil {
return
}
b.AddConn(conn)
}
}
func (w *WebsocketController) createWebsocketConnection(writer http.ResponseWriter, req *http.Request) *websocket.Conn {
upgrader := websocket.Upgrader{}
connection, err := upgrader.Upgrade(writer, req, nil)
if err != nil {
panic(err)
}
w.logger.Println("connection opened")
return connection
}
func (e eventResponse) ServeHTTP(w http.ResponseWriter, r *http.Request) {
upgrader := websocket.Upgrader{}
c, err := upgrader.Upgrade(w, r, nil)
if err != nil {
w.Write([]byte(fmt.Sprintf("websocket upgrade failed: %v", err)))
return
}
s := notifications.NewSubscriber(c, r)
e.h.Subscribe(s)
}
func Start(orientChan chan orient.Event, shootChan chan shoot.Event) {
port := 4242
var upgrader = websocket.Upgrader{
ReadBufferSize: 2048,
WriteBufferSize: 2048,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
http.HandleFunc("/control", func(w http.ResponseWriter, r *http.Request) {
log.Debug("Connection received")
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Fatal(err)
}
defer conn.Close()
for {
messageType, reader, err := conn.NextReader()
if err != nil {
log.Println(err)
return
}
if messageType == websocket.TextMessage {
packet := Packet{}
decoder := json.NewDecoder(reader)
if err := decoder.Decode(&packet); err != nil {
log.Warning(err)
continue
}
switch packet.Type {
case "orient":
event := orient.Event{}
mapstructure.Decode(packet.Payload, &event)
orientChan <- event
case "shoot":
event := shoot.Event{}
mapstructure.Decode(packet.Payload, &event)
shootChan <- event
default:
log.Info("Oops unknown packet: ", packet)
}
}
}
})
go http.ListenAndServe(fmt.Sprintf("0.0.0.0:%d", port), nil)
log.Infof("Websocket server started on port %d", port)
}
func Websocket(ctx *ink.Context) {
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
if c, err := upgrader.Upgrade(ctx.Res, ctx.Req, nil); err != nil {
Fatal(err)
} else {
conn = c
}
ctx.Stop()
}