Websocket closes after being open

[Gillardo]

Anyone have a problem with websockets? I have created my class but once i connect to the websocket, it close after about 2-3 seconds, with a code of 1006.

Here is my code, if anyone knows of anything i have done wrong.

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import fi.iki.elonen.NanoWSD;

public class MyHttpServer extends NanoWSD {
    private Context context;
    private static final int PORT = 8765;
    private List<MyWebSocket> connections = new ArrayList<MyWebSocket>();

    public MyHttpServer(Context context) throws IOException {
        super(PORT);
        this.context = context;
    }

    public List<MyWebSocket> getConnections() {
        return this.connections;
    }

    @Override
    protected WebSocket openWebSocket(IHTTPSession handshake) {
        return new MyWebSocket(handshake, this);
    }

    @Override
    public Response serveHttp(IHTTPSession session) {
        String url = session.getUri();

        // some custom code here for serving web responses

        return super.serve(session);
    }
}

And i have also created a webSocket class

import fi.iki.elonen.NanoWSD;

public class MyWebSocket extends NanoWSD.WebSocket {

    MyHttpServer httpServer;
    NanoHTTPD.IHTTPSession httpSession;

    public MyWebSocket(NanoHTTPD.IHTTPSession handshakeRequest, MyHttpServer httpServer) {
        super(handshakeRequest);
        this.httpSession = handshakeRequest;
        this.httpServer = httpServer;
    }

    @Override
    protected void onOpen() {
        httpServer.getConnections().add(this);
    }

    @Override
    protected void onClose(NanoWSD.WebSocketFrame.CloseCode code, String reason, boolean initiatedByRemote) {
        this.httpServer.getConnections().remove(this);
    }

    @Override
    protected void onMessage(NanoWSD.WebSocketFrame message) {

    }

    @Override
    protected void onPong(NanoWSD.WebSocketFrame pong) {

    }

    @Override
    protected void onException(IOException exception) {

    }
}

I am guessing this is all ok?? Why would the websocket be disconnecting after a couple seconds?

[LordFokas]

You MUST ping websockets. It's part of the protocol. That's how the server knows the client is still there.
Whoever created this implementation did not add any sort of automatical pinging, so you must do it manually.

[HussainYousuf]

@Gillardo What is your javascript implementation for webscoket

[LordFokas]

I'll just add that if you ping the socket from the server side clients will automatically pong. It has proven to be enough for me.

[Gillardo]

My websocket javscript implementation is very simple, its used for angular2 and looks like this.

import { Injectable } from '@angular/core';
import { Device } from './models/device';
import { Http } from '@angular/http';
import { DbService } from './db.service';

@Injectable()
export class WebsocketService {

    private url: string;
    private ws: WebSocket = null;

    constructor(
        private http: Http,
        private dbService: DbService) {

    }

    connect(device: Device) {
        if (this.ws == null || this.ws.readyState == WebSocket.CLOSED) {
            this.url = device.url;
            this.ws = new WebSocket(device.url.replace(/http:/g, 'ws:') + ':8766');

            // When a connection is made
            this.ws.onopen = () => { this.onOpen(); } ;

            // When data is received
            this.ws.onmessage = (e) => { this.onMessage(e); };

            // A connection could not be made
            this.ws.onerror = (e) => { this.onError(e); };

            // A connection was closed
            this.ws.onclose = (e) => { this.onClose(e); };
        }
    }

    disconnect() {
        if (this.ws) {
            this.ws.close();
        }
    }

    private onOpen() {
        console.log('Opened connection ');
    }

    private onMessage(event) {
        console.log('message received');
    }

    private onError(event) {
        console.log(event);
    }

    private onClose(reason: CloseEvent) {
        console.log(reason);
    }
}

[Gillardo]

All i need is for the client to open a connection and listen for a message. Once a message is received, the client will do something. This works if i use java_websocket but i would rather use 1 framework, then 2

[LordFokas]

Have you checked for exceptions on the server side?

[DerTomm]

I have to bring this question up again: As far as I see none of the NodeJS oder Browser implementations of WebSocket clients seem to send out a ping - which causes java.net.SocketTimeoutException: Read timed out exceptions and connections breaks every five seconds on the server side. And as far as I see the server does not send any ping frames either. So could you please tell us how to properly keep a Websocket connection open?

[LordFokas]

On my implementation I spawn a thread that every n seconds loops the list of active sockets and pings them all.

[Gillardo]

@LordFokas be very interested in that code 😄

[LordFokas]

BE ADVISED THIS MIGHT BE SUB-OPTIMAL, THIS WAS SOMEWHAT OF A HACK THAT WORKED AND I KEPT

package mohawk.http.servers;

import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

import mohawk.api.http.IWebSocketHandler;
import mohawk.http.HandlerRegistry;
import mohawk.http.MohawkWebSocket;
import fi.iki.elonen.NanoWSD;

public class MohawkWSD extends NanoWSD{
	private static final byte[] PING_PAYLOAD = "1337DEADBEEFC001".getBytes();
	private List<MohawkWebSocket> toAdd, toRemove;
	private Thread wsPinger;
	
	public MohawkWSD(String hostname, int port) {
		super(hostname, port);
	}
	
	@Override
	public void start() throws IOException {
		super.start();
		toRemove = new LinkedList<>();
		toAdd = new LinkedList<>();
		wsPinger = new Thread(new Runnable(){
			@Override public void run(){
				List<MohawkWebSocket> active = new LinkedList<>();
				long nextTime = System.currentTimeMillis();
				while(MohawkWSD.this.isAlive()){
					nextTime += 4000L;
					while(System.currentTimeMillis() < nextTime){
						try{ Thread.sleep(nextTime - System.currentTimeMillis()); }
						catch(InterruptedException ignored){}
					}
					synchronized(toAdd){
						active.addAll(toAdd);
						toAdd.clear();
					}
					synchronized(toRemove){
						active.removeAll(toRemove);
						toRemove.clear();
						for(MohawkWebSocket ws : active){
							try{ ws.ping(PING_PAYLOAD); }
							catch(Exception e){ toRemove.add(ws); }
						}
					}
				}
			}
		});
		wsPinger.setDaemon(true);
		wsPinger.start();
	}
	
	@Override
	public final MohawkWebSocket openWebSocket(IHTTPSession handshake) {
		IWebSocketHandler handler = HandlerRegistry.WS_REGISTRY.getHandler(handshake.getUri());
		MohawkWebSocket socket = new MohawkWebSocket(this, handshake, handler);
		synchronized(toAdd){
			if(!toAdd.contains(socket))
				toAdd.add(socket);
		}
		return socket;
	}
	
	public final void onSocketClose(MohawkWebSocket socket){
		synchronized(toRemove){
			if(!toRemove.contains(socket))
				toRemove.add(socket);
		}
	}
}

I also override the sockets like this, to keep track of missed pings:

	@Override
	public void ping(byte[] payload) throws IOException {
		super.ping(payload);
		this.ping++;
		if(ping - pong > 3) close(CloseCode.GoingAway, "Missed too many ping requests.", false);
	}
	
	@Override
	protected void onPong(WebSocketFrame pong){
		this.pong++;
	}

[LordFokas]

You see, my goal with the changes I attempted to introduce to NanoHTTPD in 3.0 were exactly aiming to allow setting up the system like a pipeline, where you can change components independently to add or modify behavior seamlessly in each stage. It still has a long way to go, and I'm not sure which version of the code I'm using here, it might be a commit somewhere between versions, but this should work regardless.

[DerTomm]

@LordFokas Thanks for providing your code - now I think I understand the behaviour a little bit better.

[LordFokas]

Feel free to give me feedback on it ;)

[ItsHarper]

It's probably better to use a SecheduledExecutorService(Executors.newSingleThreadScheduledExecutor()) and call scheduleAtFixedRate() instead of implementing the thread yourself. (I'm also working on implementing websockets with NanoHTTPD for a project).