Separate (underlying) datachannels for unreliable and reliable messages

[reececomo]

I think Geckos.io would benefit from creating two separate datachannels per connection, one for unreliable and one for reliable.

That would allow certain messages to leverage the existing (super fast) reliable mode at the network layer instead of reimplementing it at the application layer.

// UDP-like channel for realtime data (e.g. binary, serialized game state packets).
const unreliable = RTCPeerConnection.createDataChannel("unreliable", {
    ordered: false,
    maxRetransmits: 0
});

// TCP-like channel for reliable data (e.g. chat message, ad-hoc game state events).
const reliable = RTCPeerConnection.createDataChannel("reliable", {
    ordered: true, // optional?
    maxRetransmits: 10 // Use constant
});

Edit: Moved to #269

[eltonnobrega]

Hello. How are you?

Checking the code here, the answer is no. The gecko.io server receives a request and just creates an unreliable, unordered connection (default of @param options.ordered is false).
You can send Reliable Messages using the reliable option of emit(reliable: true). It uses one form of reliability, but there are many.
A good read are the articles by Glenn Fiedler(https://gafferongames.com/#posts).

I thought about using websocket for reliable connections, but a simplistic ordered reliable udp version will be faster.

Your idea of separating channels is good too, for example, the construct3 multiplayer plugin (where I create my games) makes 3 channels: unreliable and unordered, reliable and unordered, and reliable ordered.

[reececomo]

Yep, that is roughly what the original request asks for 😄

I don't need the "reliable but unordered" channel myself, but leveraging separate UDP-like and a TCP-like channels on the same WebRTC connection would be extremely useful.

[eltonnobrega]

How are you?
Reading a little about the subject, I was able to create a simple server just using node-datachannel and better understand how these libraries work.

In geckos itself, it is possible to open other data channels, as the peer connection is already made. Here is an example of how to open a channel as you want.

Server:

import geckos from '@geckos.io/server'

const io = geckos()

io.listen() // default port is 9208

io.onConnection(channel => {

	const peerConnection = channel.webrtcConnection.peerConnection;

	const dc_config_reliable_ordered: DataChannelInitConfig = {
		ordered: true
	}
	const dc_reliable_ordered = peerConnection.createDataChannel("reliable_ordered", dc_config_reliable_ordered);
	
	dc_reliable_ordered.onOpen(() => {
		dc_reliable_ordered.sendMessage('connected');
		dc_reliable_ordered.onMessage(msg => {
			console.log(`got ${msg} in default dc_reliable_ordered`)
			dc_reliable_ordered.sendMessage('msg pong: ' + msg);
		});
	});
	
	channel.on('chat message', data => {
		console.log(`got ${data} from "chat message" in default channel`)
	})
})

Client:

const channel = geckos({
	url: 'http://localhost'
})

channel.onConnect(error => {
	if (error) {
		console.error(error.message)
	return
	}
	
	channel_reliable_ordered = null;
	channel.peerConnection.localPeerConnection.ondatachannel = ((e) => { //RTCDataChannelEvent
		channel_reliable_ordered = e.channel;
		channel_reliable_ordered.onmessage = (e) => { //MessageEvent
			console.log(e);
		}
	});
	//channel_reliable_ordered.send("test");

	channel.on('chat message', data => {
		console.log(`You got the message ${data}`)
	})

	channel.emit('chat message', 'Hello')
})

[reececomo]

Yeah, adding it this way just misses the entire Geckosio abstraction layer. Doing this with JSON.stringify() and JSON.parse() with standard payloads is OK.

[yandeu]

I guess we could add this to the library.
I've opened a new issue.

[reececomo]

@eltonnobrega Just a note, the client needs to wait for the channel's readyState to be open otherwise it throws an InvalidStateError on send.

(For reference, I ran into this minor race condition on certain mobile browsers)

const reliableChannel = event.channel;

reliableChannel.onopen(() => {
  // Now we're ready.
  reliableChannel.send('hello')
});