Server Example in Python - Error on connect

[mjedmonds]

When running the sys-server example for a python target, I run into the following error when I connect an html-client:

INFO  :: Starting server - localhost:5000 (maxConnections: 10)
DEBUG :: ID-1 :: New socket handler
DEBUG :: ID-1 :: Adding to web server handler to list - total: 1
DEBUG :: Error selecting socket: TypeError('arguments 1-3 must be sequences')
DEBUG :: ID-1 :: Closed
1. CLOSE
DEBUG :: ID-1 :: Removing web server handler from list - total: 0

Steps to reproduce:

1. Build sys-server for python target

cd Examples/sys-server/src
haxe -python PythonMain.py --class-path ../../../ --main Main

2. Build html-client

cd Examples/html-client/src
haxe -js JSMain.js --class-path ../../../ --main Main

3. Launch server

cd Examples/sys-server/src
python PythonMain.py

4. Launch client (I made a dummy index.html that included the script from step 2).
5. Click connect on any of the panes. On the client side, I see the following error:

ready
connecting
error: [object Event]
disconnected

On the server side, I see the following

INFO  :: Starting server - localhost:5000 (maxConnections: 10)
DEBUG :: ID-1 :: New socket handler
DEBUG :: ID-1 :: Adding to web server handler to list - total: 1
DEBUG :: Error selecting socket: TypeError('arguments 1-3 must be sequences')
DEBUG :: ID-1 :: Closed
1. CLOSE
DEBUG :: ID-1 :: Removing web server handler from list - total: 0

Any ideas how this could be fixed? I don't see this error when using a C++ target for the server.

Thanks!

[ianharrigan]

Interesting, ive never actually used the python target in haxe, so this is a pretty good excuse to have a play. Ill check it out.

No idea what Error selecting socket: TypeError('arguments 1-3 must be sequences') means

What version of haxe are you using out of interest? And what version of hxWebSockets?

EDIT: Looks like this is the issue, so might be haxe bug: https://stackoverflow.com/questions/19347224/select-select-in-python-need-1-3-arguments-sequence

EDIT2: what does your %HAXE%/std/python/_std/sys/net/Socket.hx look like?

[mjedmonds]

I'm using Haxe v4.1.2 and I pulled master of hxWebSockets. I started using haxe within the last week, so I am very much an uninformed user at this point. Below are the contents of %HAXE%/std/python/_std/sys/net/Socket.hx. From the stack overflow and Socket.hx from the standard library, it looks like they are in agreement: rlist, wlist and xlist are all sequences/arrays, but I am not positive.

/*
 * Copyright (C)2005-2019 Haxe Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

package sys.net;

import haxe.io.Error;
import haxe.io.Bytes;
import haxe.io.BytesData;
import python.Exceptions;
import python.Tuple;
import python.lib.socket.Socket in PSocket;
import python.lib.Socket in PSocketModule;
import python.lib.socket.Address in PAddress;
import python.lib.Select;

private class SocketInput extends haxe.io.Input {
    var __s:PSocket;

    public function new(s) {
        __s = s;
    }

    public override function readByte():Int {
        var r:BytesData;
        try {
            r = __s.recv(1, 0);
        } catch (e:BlockingIOError) {
            throw Blocked;
        }
        if (r.length == 0)
            throw new haxe.io.Eof();
        return python.Syntax.code("r[0]");
    }

    public override function readBytes(buf:haxe.io.Bytes, pos:Int, len:Int):Int {
        var r;
        var data = buf.getData();
        try {
            r = __s.recv(len, 0);
            for (i in pos...(pos + r.length)) {
                data.set(i, r[i - pos]);
            }
        } catch (e:BlockingIOError) {
            throw Blocked;
        }
        if (r.length == 0)
            throw new haxe.io.Eof();
        return r.length;
    }

    public override function close() {
        super.close();
        if (__s != null)
            __s.close();
    }
}

private class SocketOutput extends haxe.io.Output {
    var __s:PSocket;

    public function new(s) {
        __s = s;
    }

    public override function writeByte(c:Int) {
        try {
            __s.send(python.Syntax.code('bytes([c])'), 0);
        } catch (e:BlockingIOError) {
            throw Blocked;
        }
    }

    public override function writeBytes(buf:haxe.io.Bytes, pos:Int, len:Int):Int {
        try {
            var data = buf.getData();
            var payload = python.Syntax.code("{0}[{1}:{1}+{2}]", data, pos, len);
            var r = __s.send(payload, 0);
            return r;
        } catch (e:BlockingIOError) {
            throw Blocked;
        }
    }

    public override function close() {
        super.close();
        if (__s != null)
            __s.close();
    }
}

@:coreApi class Socket {
    var __s:PSocket;

    public var input(default, null):haxe.io.Input;

    public var output(default, null):haxe.io.Output;

    public var custom:Dynamic;

    public function new():Void {
        __initSocket();
        input = new SocketInput(__s);
        output = new SocketOutput(__s);
    }

    function __initSocket():Void {
        __s = new PSocket();
    }

    public function close():Void {
        __s.close();
    }

    public function read():String {
        return input.readAll().toString();
    }

    public function write(content:String):Void {
        output.writeString(content);
    }

    public function connect(host:Host, port:Int):Void {
        var host_str = host.toString();
        __s.connect(Tuple2.make(host_str, port));
    }

    public function listen(connections:Int):Void {
        __s.listen(connections);
    }

    public function shutdown(read:Bool, write:Bool):Void
        __s.shutdown((read && write) ? PSocketModule.SHUT_RDWR : read ? PSocketModule.SHUT_RD : PSocketModule.SHUT_WR);

    public function bind(host:Host, port:Int):Void {
        var host_str = host.toString();
        __s.bind(Tuple2.make(host_str, port));
    }

    public function accept():Socket {
        var tp2:Tuple2<PSocket, PAddress> = __s.accept();
        var s = new Socket();
        s.__s = tp2._1;
        s.input = new SocketInput(s.__s);
        s.output = new SocketOutput(s.__s);
        return s;
    }

    public function peer():{host:Host, port:Int} {
        var pn = __s.getpeername();
        return {host: new Host(pn._1), port: pn._2}
    }

    public function host():{host:Host, port:Int} {
        var pn = __s.getsockname();
        return {host: new Host(pn._1), port: pn._2};
    }

    public function setTimeout(timeout:Float):Void {
        __s.settimeout(timeout);
    }

    public function waitForRead():Void {
        Select.select([this], [], []);
    }

    public function setBlocking(b:Bool):Void {
        __s.setblocking(b);
    }

    public function setFastSend(b:Bool):Void {
        __s.setsockopt(PSocketModule.SOL_TCP, PSocketModule.TCP_NODELAY, b);
    }

    @:keep function fileno():Int
        return __s.fileno();

    public static function select(read:Array<Socket>, write:Array<Socket>, others:Array<Socket>,
            ?timeout:Float):{read:Array<Socket>, write:Array<Socket>, others:Array<Socket>} {
        var t3 = Select.select(read, write, others, timeout);
        return {read: t3._1, write: t3._2, others: t3._3};
    }
}

[ianharrigan]

Yeah, looks the same as mine - and yeah, they look to be arrays right? Weird...

I guess ill have to try your steps above and see what the generated python looks like.

Cheers, Ian

[mjedmonds]

Just for an update on this - if you look at the generated Python's hx_ws_WebSocketCommon.process() implementation (line 310 on my generated version), there's the following line:

result = sys_net_Socket.select([self._socket],None,None,0.01)

Changing wlist and xlist (2nd and 3rd arg) to be empty lists works:

result = sys_net_Socket.select([self._socket],[],[],0.01)

The server can connect with the client after this manual fix (hope it helps track down the issue), but I'm hitting another error when trying to send a message.

[ianharrigan]

OK, great, what happens if you change:

https://github.com/ianharrigan/hxWebSockets/blob/master/hx/ws/WebSocketCommon.hx#L235

to

result = SocketImpl.select([_socket], [], [], 0.01);

?

Whats the other issue?