kataras / neffos Goto Github PK

I can confirm that the configuration is correct and the same configuration can connect to the cluster using go-redis.
@kataras can you add a go-redis dependency？

Locate where the error occurred：

ref: https://github.com/mediocregopher/radix/blob/edd71ccab1b4dadde5b6e422e7af086230c0cf54/cluster.go#L203-L208

WebSocket connection to 'ws://127.0.0.1:8888/echo?X-Websocket-Header-X-Username=yhm' failed: Error during WebSocket handshake: Unexpected response code: 403

Describe the bug
In V12 version, neffos websocket cannot set cross domain using gorilla library, and will prompt 403 error

My local solution is as follows：
// DefaultUpgrader is a gorilla/websocket Upgrader with all fields set to the default values.
var DefaultUpgrader = Upgrader(gorilla.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true
},
})

to Reproduce
My suggestion is that you should configure “gorilla. Upgrade {}” through the developer user

Hi all,

I try to use scaling out function with native messages,
but it doesn't work out.

First of all, I tried to use Conn.Server().Broadcast with scaling out. However, it was not working, then I tried Conn.Server().Do func instead.
Clients connect to the same ws server are able to receive messages while using Do func, but clients connect to different servers are not.

Is there any way that I can use scaling out function with native message mode?

Glad to hear your advice.
Thank you very mush for your help.

package main

import (
	"log"

	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/websocket"
	"github.com/kataras/neffos/stackexchange/nats"
)

type clientPage struct {
	Title string
	Host  string
}

func main() {
	app := iris.New()

	app.RegisterView(iris.HTML("./templates", ".html")) // select the html engine to serve templates

	// Almost all features of neffos are disabled because no custom message can pass
	// when app expects to accept and send only raw websocket native messages.
	// When only allow native messages is a fact?
	// When the registered namespace is just one and it's empty
	// and contains only one registered event which is the `OnNativeMessage`.
	// When `Events{...}` is used instead of `Namespaces{ "namespaceName": Events{...}}`
	// then the namespace is empty "".
	ws := websocket.New(websocket.DefaultGorillaUpgrader, websocket.Events{
		websocket.OnNativeMessage: func(nsConn *websocket.NSConn, msg websocket.Message) error {
			log.Printf("Server got: %s from [%s]", msg.Body, nsConn.Conn.ID())

			nsConn.Conn.Server().Broadcast(nsConn, msg)
			return nil
		},
	})

	exc, err := nats.NewStackExchange("nats://nats-streaming:4222")
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	if err != nil {
		panic(err)
	}
	ws.UseStackExchange(exc)
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

	ws.OnConnect = func(c *websocket.Conn) error {
		log.Printf("[%s] Connected to server!", c.ID())
		return nil
	}

	ws.OnDisconnect = func(c *websocket.Conn) {
		log.Printf("[%s] Disconnected from server", c.ID())
	}

	app.HandleDir("/js", "./static/js") // serve our custom javascript code.

	// register the server on an endpoint.
	// see the inline javascript code i the websockets.html, this endpoint is used to connect to the server.
	app.Get("/my_endpoint", websocket.Handler(ws))

	app.Get("/", func(ctx iris.Context) {
		ctx.View("client.html", clientPage{"Client Page", "localhost:80"})
	})

	// Target some browser windows/tabs to http://localhost:8080 and send some messages,
	// see the static/js/chat.js,
	// note that the client is using only the browser's native WebSocket API instead of the neffos one.
	app.Run(iris.Addr(":80"))
}

My just want dart run on flutter !

Has develop plan?

hello
I want to implement a function with websocket.
the details are as follows：
i want to create a room and the room will return me an id.
When someone connects to service using websocket,he can via id to find the room and connect it.
How do I implement it？....

Hello, @kataras , I am using the room function provided by neffos, and In my case I am not sure whether the client-side can call the Leave() method correctly, which may cause the room to not be properly recycled? Can the server-side manually disconnect the specified client connection to the room?

Rooms storage variable:

RoomJoin:

RoomLeave:

I see old WebSocket library has been depreciated. Why the new WebSocket library "neffos"?

Is there any performance difference?

It is always return default id.

	events := make(websocket.Namespaces)
	events["willnet"]=controller.Willnet()

	websocketServer := websocket.New(websocket.DefaultGobwasUpgrader, events)

	websocketServer.IDGenerator = func(w http.ResponseWriter, r *http.Request) string {
		log.Println(111111)
		jwtStr:=r.Header.Get("jwt")
		token:=new(jwt.Token)
		if jwtStr == ""{
			return websocket.DefaultIDGenerator(nil)
		}
		err:=json.Unmarshal([]byte(jwtStr),token)
		if err!=nil{
			return websocket.DefaultIDGenerator(nil)
		}
		user := token.Claims.(jwt.MapClaims)
		return user["account"].(string)
	}

......

	websocketRouter := app.Get("/websocket/echo", websocket.Handler(websocketServer))

	//jwt
	jwtHandler := jwt.New(jwt.Config{
		Extractor:jwt.FromAuthHeader,
		ValidationKeyGetter: func(token *jwt.Token) (i interface{}, e error) {
			return []byte(os.Getenv("JWT_SECRET")),nil
		},
		SigningMethod:jwt.SigningMethodHS256,
	})

	websocketRouter.Use(jwtHandler.Serve)

When the client joined room, the server-side does not print '111111'.

Describe the bug
After upgrade lastest version, it still happened on productions. Debugging by dlv tool, I found the neffos block whole process.

Screenshots

Desktop (please complete the following information):

• OS: Centos
• Version 7.7

Could you have time to handle this questions?

https://github.com/gorilla/websocket/releases/tag/v1.4.1
This release fixes a potential denial-of-service (DoS) vector in gorilla/websocket, and we recommend that all users upgrade to this version (v1.4.1) or later

Describe the bug
I have an issue with cors, when i run it the example in 2 diferents ports (3000, 3001) and i try to conect a new socket from 3001 to 3000 then the console throw the next error:
WebSocket connection to 'ws://localhost:3001/echo?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjozMjEzMjF9.8waEX7-vPKACa-Soi1pQvW3Rl8QY-SUFcHKTLZI4mvU' failed: Error during WebSocket handshake: Unexpected response code: 403.

To Reproduce
Use the example server.go on the route: _examples/websocket/basic/

package main

import (
	"log"

	"github.com/kataras/iris"
	"github.com/kataras/iris/websocket"

	// Used when "enableJWT" constant is true:
	"github.com/iris-contrib/middleware/jwt"
)

// values should match with the client sides as well.
const enableJWT = true
const namespace = "default"

// if namespace is empty then simply websocket.Events{...} can be used instead.
var serverEvents = websocket.Namespaces{
	namespace: websocket.Events{
		websocket.OnNamespaceConnected: func(nsConn *websocket.NSConn, msg websocket.Message) error {
			// with `websocket.GetContext` you can retrieve the Iris' `Context`.
			ctx := websocket.GetContext(nsConn.Conn)

			log.Printf("[%s] connected to namespace [%s] with IP [%s]",
				nsConn, msg.Namespace,
				ctx.RemoteAddr())
			return nil
		},
		websocket.OnNamespaceDisconnect: func(nsConn *websocket.NSConn, msg websocket.Message) error {
			log.Printf("[%s] disconnected from namespace [%s]", nsConn, msg.Namespace)
			return nil
		},
		"chat": func(nsConn *websocket.NSConn, msg websocket.Message) error {
			// room.String() returns -> NSConn.String() returns -> Conn.String() returns -> Conn.ID()
			log.Printf("[%s] sent: %s", nsConn, string(msg.Body))

			// Write message back to the client message owner with:
			// nsConn.Emit("chat", msg)
			// Write message to all except this client with:
			nsConn.Conn.Server().Broadcast(nsConn, msg)
			return nil
		},
	},
}

func main() {
	app := iris.New()
	websocketServer := websocket.New(
		websocket.DefaultGorillaUpgrader, /* DefaultGobwasUpgrader can be used too. */
		serverEvents)

	j := jwt.New(jwt.Config{
		// Extract by the "token" url,
		// so the client should dial with ws://localhost:8080/echo?token=$token
		Extractor: jwt.FromParameter("token"),

		ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
			return []byte("My Secret"), nil
		},

		// When set, the middleware verifies that tokens are signed
		// with the specific signing algorithm
		// If the signing method is not constant the
		// `Config.ValidationKeyGetter` callback field can be used
		// to implement additional checks
		// Important to avoid security issues described here:
		// https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/
		SigningMethod: jwt.SigningMethodHS256,
	})

	idGen := func(ctx iris.Context) string {
		if username := ctx.GetHeader("X-Username"); username != "" {
			return username
		}

		return websocket.DefaultIDGenerator(ctx)
	}

	// serves the endpoint of ws://localhost:8080/echo
	// with optional custom ID generator.
	websocketRoute := app.Get("/echo", websocket.Handler(websocketServer, idGen))

	if enableJWT {
		// Register the jwt middleware (on handshake):
		websocketRoute.Use(j.Serve)
		// OR
		//
		// Check for token through the jwt middleware
		// on websocket connection or on any event:
		/* websocketServer.OnConnect = func(c *websocket.Conn) error {
		ctx := websocket.GetContext(c)
		if err := j.CheckJWT(ctx); err != nil {
			// will send the above error on the client
			// and will not allow it to connect to the websocket server at all.
			return err
		}

		user := ctx.Values().Get("jwt").(*jwt.Token)
		// or just: user := j.Get(ctx)

		log.Printf("This is an authenticated request\n")
		log.Printf("Claim content:")
		log.Printf("%#+v\n", user.Claims)

		log.Printf("[%s] connected to the server", c.ID())

		return nil
		} */
	}

	// serves the browser-based websocket client.
	app.Get("/", func(ctx iris.Context) {
		ctx.ServeFile("./browser/index.html", false)
	})

	// serves the npm browser websocket client usage example.
	app.HandleDir("/browserify", "./browserify")

	app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed))
}

Expected behavior
I would like to make petitions from the 2 servers

Posible fix
To catch this i made a middleware function wich delete the origin header (but this will be a rellay bad practice), code above:

        app.Use(func(ctx iris.Context) {
		ctx.Request().Header.Del("Origin")
		ctx.Next()
	})

#387 I have read this issue. But cannot found, websocket.Config

Then i found that, Iris websocket library is now merged with the neffos real-time framework
But i cann't find a correct way to send binary data with neffos.

Is there any config for neffos to send binary instead of string?

How Sending message to specific user with neffos ?
I can not found Broadcast message to a connectionId

two problems：
1、How the system pushes announcements to every online user？
2、How to regularly promote announcements ？

Hi @kataras i try to replicate the example of Ask function between 2 go api but server side never catch the response from Reply function in client side.

Like socketio or signalr, they provide serval adapters such as redis.
Hope neffos could provide the adapter interface. let users could add their own implemention;
And It would be great for builtin support serval great pubsub system like redis and nats

Thanks again for the great library.

How to send heartbeat to client？

thank you for the nice library .

Multiplexed connection, Send multiple Ask on the same connection at the same time.

I used iris in my go program,and i should build a wechat mini-program as front end
I can't npm install it !!!
When the front-end worked without neffos.js ,the bug appeared!!
Connected successed , but no any responses , neither server and client

debug.go:116:18

WebSocket connection to 'ws://127.0.0.1:8888/echo?X-Websocket-Header-X-Username=yhm' failed: Error during WebSocket handshake: Unexpected response code: 403

Hello,

This is more of a question: is there a dart/flutter client for this library? I couldn't find one, and there seems to be nothing about it here in the issues as well.

Thanks,
Howe

I want to build a private room.
The client can join the private room but it must complete the authentication.
So I need to send authentication information to the server to determine whether the client's request to join is illegal.
But I find that nsConn.JoinRoom(ctx, "room") does not provide a way to send a custom message.
the following function also can't provide Message#Body filed:
neffos.OnRoomJoined: func(c *neffos.NSConn, msg neffos.Message) error
The client seems to be able to forcibly join any specific room.it bypass my certification.
I am a newcomer if I miss some useful API?

Hi @kataras, I started to use neffos nearly weak ago and i really like it, where i work we decide to move into real time aplication, and i searched for a good socket package, i already used iris and i really like how it works, i was working with websockets of iris and when i updated iris i see some errors (i was in trubles before because updates of other libraries we use), then i read the documentation and i've changed all.

I also integrate the sockets with echo framework and i wold like to leave here how i made it for anyone who need it and also i think it will be good for this greate library if they have examples of implementatios with other to.

Then here is the code:

package main

import (
	"github.com/labstack/echo"
        "github.com/kataras/neffos"
	"github.com/kataras/neffos/gorilla"
	"github.com/labstack/echo"
)

type serverConn struct {
	*neffos.NSConn
}

func main() {
        router := echo.New()

        controller := new(serverConn)
        events := neffos.NewStruct(controller).
		SetNamespace("default").
		SetEventMatcher(neffos.EventTrimPrefixMatcher("On"))

        websocketServer := neffos.New(
		gorilla.DefaultUpgrader, /* DefaultGobwasUpgrader can be used too. */
		events)

       // Wrap the web socket handler with echo function to be compatible, both use http library to work
       router.Any("/echo", echo.WrapHandler(websocketServer), deleteOrigin)

        if err := router.Start(":8080"); err != nil {
		log.Fatalf("error in ListenAndServe: %s", err)
	}
}

// deleteOrigin allows others origins than local access to sockets
// if we avoid this handler then we can't connect from servers in other ports or routes
// NOTE: This isn't the best way to do it, but i can't found another way to do it.
func deleteOrigin(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		c.Request().Header.Del("Origin")
		return next(c)
	}
}

func (c *serverConn) OnNamespaceConnected(msg neffos.Message) error {
	log.Printf("[%s] connected to namespace [%s]",
		c.Conn, msg.Namespace)
	return nil
}

func (c *serverConn) OnNamespaceDisconnect(msg neffos.Message) error {
	log.Printf("[%s] disconnected from namespace [%s]", c.Conn, msg.Namespace)
	return nil
}

func (c *serverConn) OnChat(msg neffos.Message) error {
	log.Printf("[%s] sent: %s", c.Conn, string(msg.Body))
	c.Conn.Server().Broadcast(c.Conn, msg)
	return nil
}

This is only for the server file, if anyone want to test it use with the files in the route: _examples/basic/browser

One las thing: I don't know how to acces to the context of the request.

The client-side JoinRoom method cannot pass metadata to the server-side for authenticating.
for now, the rooms are accessible to all users, but in some situations, we need only allow specific users to join some rooms.

Hello, excuse me, I want to transfer my application to neffos. How does neffos send messages to websocket thread in web thread? Just like the socket.io-emitter package of node.js socketio

Sorry to bother you. But i have found the bug.
It is in neffos.js.

I'm using protobuf with neffos.js. The data that protobuf make counld contain ;. So that my message will be drop in neffos.js in here.

  var isArrayBuffer = data instanceof ArrayBuffer;
    var dts;

    console.log(isArrayBuffer)

    if (isArrayBuffer) {
        var arr = new Uint8Array(data);
        var sepCount = 1;
        var lastSepIndex = 0;
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] == messageSeparatorCharCode) { // sep char.
                sepCount++;
                lastSepIndex = i;
            }
        }
       // Drop here!!!!!!!!!!!!
        if (sepCount != validMessageSepCount) {
            msg.isInvalid = true;
            console.log("return at validMessageSepCount")
            return msg;
        }
        dts = splitN(textDecoder.decode(arr.slice(0, lastSepIndex)), messageSeparator, validMessageSepCount - 2);
        dts.push(data.slice(lastSepIndex + 1, data.length));
        msg.SetBinary = true;
    }
    else {
        dts = splitN(data, messageSeparator, validMessageSepCount - 1);
    }

I thank it is a bug. Cannot just split message by ;.

Here is the reproducible code.

Server

package main

import (
	"github.com/kataras/iris"
	"fmt"
	"github.com/kataras/iris/websocket"
	"github.com/kataras/neffos"
	"time"
)

// 全局变量
var page = struct {
    Title string
}{"Collector"}

func main(){
	app := iris.New()

	ws_server := startWebSocketServer(app)

	go pub_thread(ws_server)

	app.RegisterView(iris.HTML("./static", ".html"))
	app.Get("/" ,func(ctx iris.Context){
		ctx.ViewData("Page", page)
		ctx.View("index.html")
	})

	app.HandleDir("/", "./static")	
    app.Run(iris.Addr(":5000"), iris.WithoutPathCorrection)
}

var serverEvents = websocket.Namespaces{
	"default": websocket.Events{
		websocket.OnNamespaceConnected: func(nsConn *websocket.NSConn, msg websocket.Message) error {
			// with `websocket.GetContext` you can retrieve the Iris' `Context`.
			ctx := websocket.GetContext(nsConn.Conn)

			fmt.Printf("[%s] connected to namespace [%s] with IP [%s]\n",
				nsConn, msg.Namespace,
				ctx.RemoteAddr())
			return nil
		},
		websocket.OnNamespaceDisconnect: func(nsConn *websocket.NSConn, msg websocket.Message) error {
			fmt.Printf("[%s] disconnected from namespace [%s]\n", nsConn, msg.Namespace)
			return nil
		},
		"stream": func(nsConn *websocket.NSConn, msg websocket.Message) error {
			// room.String() returns -> NSConn.String() returns -> Conn.String() returns -> Conn.ID()
			fmt.Printf("[%s] sent: %s", nsConn, string(msg.Body))

			// Write message back to the client message owner with:
			// nsConn.Emit("chat", msg)
			// Write message to all except this client with:
			nsConn.Conn.Server().Broadcast(nsConn, msg)
			return nil
		},
	},
}

func startWebSocketServer(app *iris.Application) *neffos.Server{
	server := websocket.New(websocket.DefaultGorillaUpgrader, serverEvents)
	server.OnConnect = func(c *websocket.Conn) error {
		fmt.Printf("[%s] connected to the server.\n", c)
		
		return nil
	}

	server.OnDisconnect = func(c *websocket.Conn){
		fmt.Printf("[%s] disconnected from the server.", c)
	}

	fmt.Printf("Listening on: %d\nPress CTRL/CMD+C to interrupt.\n", 5000)

	idGen := func(ctx iris.Context) string {
		if username := ctx.GetHeader("X-Username"); username != "" {
			return username
		}

		return websocket.DefaultIDGenerator(ctx)
	}

	app.Get("/stream", websocket.Handler(server, idGen))

	return server
}

func pub_thread(serve *neffos.Server){
	png:= [...] byte{';',';',';',';',';'}
	slice := png[:]
	for{
		serve.Broadcast(nil, neffos.Message{SetBinary: true,  Body:slice, Namespace: "default"})
		time.Sleep(1*time.Second)
	}
}

Client

<html>
    <button> useless button</button>

    <script src="https://cdn.jsdelivr.net/npm/neffos.js@latest/dist/neffos.js"></script>
    <script>
    
        var scheme = document.location.protocol == "https:" ? "wss" : "ws";
        var port = document.location.port ? ":" + document.location.port : "";
        var wsURL = scheme + "://" + document.location.hostname + port + "/stream";
        
        function handleError(reason) {
            console.log(reason);
        }
        
        function handleNamespaceConnectedConn(nsConn) {

        }
        // const username = window.prompt("Your username?");
        async function runExample() {
            // You can omit the "default" and simply define only Events, the namespace will be an empty string"",
            // however if you decide to make any changes on this example make sure the changes are reflecting inside the ../server.go file as well.
            try {
                const conn = await neffos.dial(wsURL, {
                    default: { // "default" namespace.
                        _OnNamespaceConnected: function (nsConn, msg) {
                            handleNamespaceConnectedConn(nsConn)
                        },
                        _OnNamespaceDisconnect: function (nsConn, msg) {
                        },
                        stream: function (nsConn, msg) { // "stream" event.
                            console.log(msg.Body);
                            console.log(msg)
                        }
                    }
                },{
                    headers: {
                        "X-Username": "",
                    }
                });
                // You can either wait to conenct or just conn.connect("connect")
                // and put the `handleNamespaceConnectedConn` inside `_OnNamespaceConnected` callback instead.
                // const nsConn = await conn.connect("default");
                // nsConn.emit(...); handleNamespaceConnectedConn(nsConn);
                conn.connect("default");
            } catch (err) {
                handleError(err);
            }
        }

        runExample()
    </script>
</html>

hi, the default websocket response is string, and messageSeparator is ;

;default;;chat;0;0;4

how can i modify, overwrite to json format

{
"Namespace": "default",
"Room" : "room1",
"Event": "chat",
"Body": "xxxxxx"
}

thx!

fatal error: concurrent map iteration and map write

goroutine 46 [running]:
runtime.throw(0x1842c28, 0x26)
/usr/local/Cellar/go/1.14.4/libexec/src/runtime/panic.go:1116 +0x72 fp=0xc002fd9bf8 sp=0xc002fd9bc8 pc=0x433a62
runtime.mapiternext(0xc002fd9cd0)
/usr/local/Cellar/go/1.14.4/libexec/src/runtime/map.go:853 +0x552 fp=0xc002fd9c78 sp=0xc002fd9bf8 pc=0x40f5e2
runtime.mapiterinit(0x1603200, 0xc000e9bf80, 0xc002fd9cd0)
/usr/local/Cellar/go/1.14.4/libexec/src/runtime/map.go:843 +0x1c4 fp=0xc002fd9c98 sp=0xc002fd9c78 pc=0x40ef94
github.com/kataras/neffos.(*Server).GetConnections(0xc0008c6700, 0x0)
/Users/near/go/pkg/mod/github.com/kataras/[email protected]/server.go:606 +0x9b fp=0xc002fd9d40 sp=0xc002fd9c98 pc=0x10b8b6b

@kataras I have Issue with

server.Broadcast(nil,neffos.Message{
To: userID,
Namespace: variable.Agent,
Event:     "notif",
Body:      neffos.Marshal(nf),	
})

i use gobwas.DefaultUpgrader

when i use server.Broadcast in loop it is work but But not very good.
You can test yourself.
i open multiple browser tap with same userId(socketId)

server.brodacast not send all message in loop;

you can see cron example .

c.write(neffos.Message{
To: userID,
Namespace: variable.Agent,
Event:     "notif",
Body:      neffos.Marshal(nf),	
})

write() mthod work very very good
but it send message to one tap (last) with same userId .

I'm going to send it to all the tabs. with same userId

Great writer kataras ：

In the demo given by websocket, the ws open link starts with "http://xxx", and then connect in the way of Upgrade! ! Now the project needs to be compatible with the mobile app and needs the "ws://xxx" style. How can I change it? please help me

Describe the bug
Call GetConnectionsByNamespace appeared abnormal

Note, if that bugs is a browser relative please report it at the neffos.js repository instead.

Screenshots
If applicable, add screenshots to help explain your problem.

Desktop (please complete the following information):

• OS: UBUNTU
• Version 18.04.02

thank you for the nice library .

When the remote connection is disconnected, Ask should immediately returns failure .

I use Ask for rpc.

I've working around with Rooms and has a special case that need to call ask function with message's Room property.

For now, i could use connection's ask function but i think implement ask function for rooms would make a better structure.

At last, thank you for the nice library and framework.

I want to integrate websocket to my project, and I have a plan using nodejs/socket.io. and after looked at the neffos project carefully, I consider using this library.
But does it ready for production now ?
Thank you for contribute many wonderful projects !

Hello! I'm very interested in using neffos to build a chat application. Scaling has been a concern in the past, and I found neffos after researching scalable websocket implementations in Go.

So I'm trying to wrap my head around how deployment works with neffos if I want a scalable setup. We currently deploy in kubernetes. Is it possible to create a redis cluster, scale up several neffos-based miniservices, and allow any client to connect to any room from any instance of the server? Or do all clients connecting to the same room have to be connected to the same backend instance? That would be fantastic if it's the former.

Thank you

Describe the bug
Sometimes the message sent arrives more than once on the server side.
I can't reproduce the problem, it is happening with some of my clients, currently between an Android emulator and an Android device, on same network.
Do I need to create some kind of MSG ID, and control messages that arrives more than once? And is that really possible?
Currently, I'm using gobwas Dialers.

To Reproduce

• Client send messages like this:

	// client sending message - ONCE
	c.Conn.Write(neffos.Message{
		Namespace: "default",
		Room:      "A_ROOM",
		Event:     "AN_EVENT",
		Body:      anyBytesArr,
		SetBinary: true,
	})

• Server send messages like this:

	// server sending message - TWICE, since it arrives 2 times instead of one
	c.Conn.Server().Broadcast(c, neffos.Message{
		Namespace: "default",
		Room:      "A_ROOM",
		Event:     "AN_EVENT",
		Body:      anyBytesArr,
		SetBinary: true,
	})

Expected behavior
Client send a message once, it arrives just once on server.

Logs
Server logs:
2020/02/07 10:00:34 [e4e6f308-680d-4a36-ae06-e90d5c44c623][Room: A_ROOM][Event: AN_EVENT]
2020/02/07 10:00:34 [e4e6f308-680d-4a36-ae06-e90d5c44c623][Room: A_ROOM][Event: AN_EVENT]

Desktop (please complete the following information):

• OS: [Linux, Android, GoMobile]
• Version [Ubuntu 18.04.3 LTS, Android any, Go 1.13.4]

Additional context
I'm using GoMobile to compile the client version and use it on an Android app (yay! works on iOS and Android!)

Describe the bug
SyncBroadcaster = true // I don’t know why setting it to false will cause some broadcasts to not be sent at the same time, so I set it to true

Hi, @kataras, currently our project has an average of 10 broadcasts per second, and there are 10 users in the room, and there may be more later. When the broadcast method is frequently called, the transmission will be blocked until it returns to normal after a period of time. I don’t know how to debug or optimize the code logic. Can you provide information on how the relevant broadcast methods work, or is there a better way to recommend how to send broadcasts frequently?

Can IOS or Android (swift or JAVA) be used as a client to connect to neffos? How can I connect? Are there any documents or ideas?

Is your feature request related to a problem? Please describe.

1, I tried neffos, it works great, but seems it only focused on Message event. But for app layer, maybe want to collect some information about: connection count, each connection startTime and endTime, last activeTime, and so on.

2, send broadcast PING from server to all client. For mobile network, APP may hibernate at background, which can't send PING. so need server to send PING to remain the TCP connection and APP alive.

3, able to do authentication when websockt upgrade, like pass the http.Request and return a simple true or false. so the app layer can read url and param from http.Request. for example: http://xxxx/ws/endpoint?uid=aaa&token=bbb

Describe the solution you'd like
1, export some event for each connection, like: CONNECT, CLOSE, ACTIVE(stand for: message, ping, pong) ......

2, able to broadcast PING

3, export handler for authentication, which default return true

I'm use neffos.js code :

But i'm find console loop print re-connected , time is i'm set reconnect , This is keeplive?

And find console print send HEAD methods to set endpoint , I'm set iris to Any but is not work

The Head request how to success?

I'm client how to keeplive? if use reconnect , I'm iris log all reconnected log , is not good~

thanks for help ~ @kataras

Describe the bug

I use neffos as WebSocket server to handler all WebSocket connects from browser.
It is running well when first deploy the web Application on production server. However it became weird at some moment. The CPU became 100% usage, and the server could not handle any incoming WebSocket connection. Debugging by dlv tool, I found the neffos conn's goroutine block main process. I don't know how reproduce this bug, but it happened several times on productions environment.

To Reproduce

Expected behavior
I hope how to avoid this situation or this is the bug.

Screenshots

Desktop (please complete the following information):

• OS: Centos
• Version 7

I want to do something when closing, or interrupting the client connection, such as cleaning up. I call conn.Close() on ws.OnConnect{} without triggering ws.OnDisconnect{}. what should I do?

package main

import (
    "fmt"
    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/websocket"
    "github.com/kataras/neffos"
)

func main() {
    app := iris.Default()
    
    ws := neffos.New(websocket.DefaultGorillaUpgrader, neffos.Namespaces{
    	neffos.OnNativeMessage: neffos.Events{
    	    "login": func(ns *neffos.NSConn, msg neffos.Message) error {
    	        return nil
    	    },
    	},
    })
    
    ws.OnConnect = func(conn *neffos.Conn) error {
        allowConnect = true
        // some operations...
        if !allowConnect {
            conn.Close()
        }
    	return nil
    }
    
    ws.OnDisconnect = func(c *neffos.Conn) {
        // No shutdown signal is received and the method body is not triggered.
    	fmt.Println("OnDisconnect")
    }
    
    app.Get("/login", websocket.Handler(ws))
    app.Logger().Fatal(app.Listen(":8080"))
}

VM137:1 WebSocket connection to 'ws://localhost:8080/my_endpoint' failed: Error during WebSocket handshake: Unexpected response code: 403

run in https://github.com/kataras/iris/blob/master/_examples/websocket/native-messages/main.go

w = new WebSocket("ws://localhost:8080/my_endpoint")

I just use example in https://github.com/kataras/iris/blob/master/_examples/websocket/basic/server.go

After run this server, I cannot access from python script.

The Python Script:

from websocket import create_connection
ws = create_connection("ws://127.0.0.1:8080/echo?X-Websocket-Header-X-Username=ok&token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjozMjEzMjF9.8waEX7-vPKACa-Soi1pQvW3Rl8QY-SUFcHKTLZI4mvU")
print("Sending 'Hello, World'...")
ws.send("Hello, World")
print("Sent")
print("Receiving...")
result =  ws.recv()
print("Received '%s'" % result)
ws.close()

And the result shows that script can establish a connection, but when the client begins to receive , it shows that "WebSocketConnectionClosedException: Connection is already closed."

This problem also happens when I serve "./broswer/index.html" at another port using another web quick server (the index.html file has been modified so that the websocket port is still the same as server-side, that is, 8080.), it shows that

neffos.min.js:1 WebSocket connection to 'ws://0.0.0.0:8080/echo?X-Websocket-Header-X-Username=jhi&token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjozMjEzMjF9.8waEX7-vPKACa-Soi1pQvW3Rl8QY-SUFcHKTLZI4mvU' failed: Error during WebSocket handshake: Unexpected response code: 403

So what should I do? And can you help me with a python websocket client script? Because I will use python script to listen and handle the websocket broadcasting message. Thank you.