RejectedSoftware Forums

On Sun, 19 Oct 2014 03:04:28 GMT, Etienne Cimon wrote:

How about changing the loop to while(_connection.dataAvailableForRead) ? I doubt you'd ever block if you used that.

Thanks for the help. I tried dataAvailableForRead again but always returns false. It doesn't resolve the problem.

Not sure about leastSize maxing out at 4096, that seems very unlikely. How did you measure it?

I inserted writeln to after leastSize.

    ubyte[] result;
    do {
        writeln("before leastSize");
        auto size = input.leastSize;
        writeln("size: ", size);
        if (size == 0) {
            proccessRequest(result);
            break;
        }
        ubyte[] data = new ubyte[](size);
        input.read(data);
        result ~= data;
    } while (_connection.connected);

My test code:

• test_server.d

import msgpackrpc;
import std.stdio;
import std.array, std.range, std.conv;

class HelloServer
{
    size_t len;

    this(size_t l)
    {
        len = l;
    }

    string hello(string msg)
    {
        return cast(string)array(repeat('f', len));
    }
}

void main(string[] args)
{ 
    auto len = to!size_t(args[1]);
    auto server = new TCPServer!(HelloServer)(new HelloServer(len));
    server.listen(Endpoint(18800, "127.0.0.1"));
    server.start();
}

• test_client.d

import msgpackrpc;
import std.stdio;
import std.array, std.range;

void main()
{
    auto client = new TCPClient(Endpoint(18800, "127.0.0.1"));

    // sync request
    writeln(client.call!string("hello", array(repeat('f', 4100))).length);
}

The result is

before leastSize
size: 4096
before leastSize
size: 11
before leastSize
# blocking until server terminated