[Caml-list] Async Server not executing

[Caml-list] Async Server not executing

[Kenneth Adam Miller]

[-- Attachment #1: Type: text/plain, Size: 1158 bytes --]

I'm having trouble with OCaml Async. I wrote a small server with it, and
right now I'm trying to unit test that server. Here's my code for the
server:


let _main ()=
  print_endline "Server running";
  let handler = print_endline in
  let socket = Tcp.on_port 5554 in
  let server = Tcp.Server.create socket (fun addr r w ->
      (Reader.contents r) >>| handler; (Writer.write w "got it")) in
  server



In my unit test code I have:

let test_shutdown test_ctxt = Thread_safe.block_on_async_exn (fun () -> (
      print_endline "test_shutdown";
      let server = Server._main () in
      server >>= fun server ->
      let where = Tcp.to_host_and_port "127.0.0.1" 5554 in
      Tcp.connect where >>= fun s ->
        let socket, r, w = s in
        ignore (Writer.write w "kill");
        ignore (Writer.flushed w);
        (Reader.recv r >>> function
          | `Ok result ->  print_endline ("writing shutdown to server" ^
result)
          | `Eof -> ());
        return ()
    )); ()



I see test_shutdown and Server running, but not sign of "writing shutdown
to server" or even "got it"; why isn't my server or even any of the
connection executing?

[-- Attachment #2: Type: text/html, Size: 19448 bytes --]

Re: [Caml-list] Async Server not executing

[David House]

[-- Attachment #1: Type: text/plain, Size: 1488 bytes --]

The first thing to try is to make sure that everything is getting flushed.
For temporary debugging messages I strongly recommend just using
[Core.Std.eprintf "<message>\n%!"].

On 16 June 2015 at 16:03, Kenneth Adam Miller <kennethadammiller@gmail.com>
wrote:

> I'm having trouble with OCaml Async. I wrote a small server with it, and
> right now I'm trying to unit test that server. Here's my code for the
> server:
>
>
> let _main ()=
>   print_endline "Server running";
>   let handler = print_endline in
>   let socket = Tcp.on_port 5554 in
>   let server = Tcp.Server.create socket (fun addr r w ->
>       (Reader.contents r) >>| handler; (Writer.write w "got it")) in
>   server
>
>
>
> In my unit test code I have:
>
> let test_shutdown test_ctxt = Thread_safe.block_on_async_exn (fun () -> (
>       print_endline "test_shutdown";
>       let server = Server._main () in
>       server >>= fun server ->
>       let where = Tcp.to_host_and_port "127.0.0.1" 5554 in
>       Tcp.connect where >>= fun s ->
>         let socket, r, w = s in
>         ignore (Writer.write w "kill");
>         ignore (Writer.flushed w);
>         (Reader.recv r >>> function
>           | `Ok result ->  print_endline ("writing shutdown to server" ^
> result)
>           | `Eof -> ());
>         return ()
>     )); ()
>
>
>
> I see test_shutdown and Server running, but not sign of "writing shutdown
> to server" or even "got it"; why isn't my server or even any of the
> connection executing?
>

[-- Attachment #2: Type: text/html, Size: 18659 bytes --]

Re: [Caml-list] Async Server not executing

[Kenneth Adam Miller]

[-- Attachment #1: Type: text/plain, Size: 1783 bytes --]

So, now I can get server received if I add that into the callback, but at
"writing shutdown to server" I don't see response received or even
something for Eof.

On Tue, Jun 16, 2015 at 11:09 AM, David House <dhouse@janestreet.com> wrote:

> The first thing to try is to make sure that everything is getting flushed.
> For temporary debugging messages I strongly recommend just using
> [Core.Std.eprintf "<message>\n%!"].
>
> On 16 June 2015 at 16:03, Kenneth Adam Miller <kennethadammiller@gmail.com
> > wrote:
>
>> I'm having trouble with OCaml Async. I wrote a small server with it, and
>> right now I'm trying to unit test that server. Here's my code for the
>> server:
>>
>>
>> let _main ()=
>>   print_endline "Server running";
>>   let handler = print_endline in
>>   let socket = Tcp.on_port 5554 in
>>   let server = Tcp.Server.create socket (fun addr r w ->
>>       (Reader.contents r) >>| handler; (Writer.write w "got it")) in
>>   server
>>
>>
>>
>> In my unit test code I have:
>>
>> let test_shutdown test_ctxt = Thread_safe.block_on_async_exn (fun () -> (
>>       print_endline "test_shutdown";
>>       let server = Server._main () in
>>       server >>= fun server ->
>>       let where = Tcp.to_host_and_port "127.0.0.1" 5554 in
>>       Tcp.connect where >>= fun s ->
>>         let socket, r, w = s in
>>         ignore (Writer.write w "kill");
>>         ignore (Writer.flushed w);
>>         (Reader.recv r >>> function
>>           | `Ok result ->  print_endline ("writing shutdown to server" ^
>> result)
>>           | `Eof -> ());
>>         return ()
>>     )); ()
>>
>>
>>
>> I see test_shutdown and Server running, but not sign of "writing shutdown
>> to server" or even "got it"; why isn't my server or even any of the
>> connection executing?
>>
>
>

[-- Attachment #2: Type: text/html, Size: 19256 bytes --]

Re: [Caml-list] Async Server not executing

[David House]

[-- Attachment #1: Type: text/plain, Size: 2631 bytes --]

Ah, now I read your code in more detail I think I see why.

Reader.contents on the server side will block until eof. The client side
sends some stuff, but does not close the writer, so the server never sees
eof. (Recall that sockets are not like files: it's possible to read all of
the available data right now, but not reach eof.)

Network protocols normally have some explicit "this is the end of one
message" marker, like a newline or something similar. Then the server just
reads chunks until it sees that marker, at which point it can put the
message together and to something with it.

For example, you could use Writer.write_line on the client side and
Reader.read_line on the server side.

On 16 June 2015 at 16:36, Kenneth Adam Miller <kennethadammiller@gmail.com>
wrote:

> So, now I can get server received if I add that into the callback, but at
> "writing shutdown to server" I don't see response received or even
> something for Eof.
>
> On Tue, Jun 16, 2015 at 11:09 AM, David House <dhouse@janestreet.com>
> wrote:
>
>> The first thing to try is to make sure that everything is getting
>> flushed. For temporary debugging messages I strongly recommend just using
>> [Core.Std.eprintf "<message>\n%!"].
>>
>> On 16 June 2015 at 16:03, Kenneth Adam Miller <
>> kennethadammiller@gmail.com> wrote:
>>
>>> I'm having trouble with OCaml Async. I wrote a small server with it, and
>>> right now I'm trying to unit test that server. Here's my code for the
>>> server:
>>>
>>>
>>> let _main ()=
>>>   print_endline "Server running";
>>>   let handler = print_endline in
>>>   let socket = Tcp.on_port 5554 in
>>>   let server = Tcp.Server.create socket (fun addr r w ->
>>>       (Reader.contents r) >>| handler; (Writer.write w "got it")) in
>>>   server
>>>
>>>
>>>
>>> In my unit test code I have:
>>>
>>> let test_shutdown test_ctxt = Thread_safe.block_on_async_exn (fun () ->
>>> (
>>>       print_endline "test_shutdown";
>>>       let server = Server._main () in
>>>       server >>= fun server ->
>>>       let where = Tcp.to_host_and_port "127.0.0.1" 5554 in
>>>       Tcp.connect where >>= fun s ->
>>>         let socket, r, w = s in
>>>         ignore (Writer.write w "kill");
>>>         ignore (Writer.flushed w);
>>>         (Reader.recv r >>> function
>>>           | `Ok result ->  print_endline ("writing shutdown to server"
>>> ^ result)
>>>           | `Eof -> ());
>>>         return ()
>>>     )); ()
>>>
>>>
>>>
>>> I see test_shutdown and Server running, but not sign of "writing
>>> shutdown to server" or even "got it"; why isn't my server or even any of
>>> the connection executing?
>>>
>>
>>
>

[-- Attachment #2: Type: text/html, Size: 20448 bytes --]

Re: [Caml-list] Async Server not executing

[Kenneth Adam Miller]

[-- Attachment #1: Type: text/plain, Size: 3437 bytes --]

Ah. Well I think I can incorporate from that what I can, but my unit tests
need to be reflective of the use case I have. I'm sending protobuf encoded
messages between two processes on one machine-whatever the size of the
message, that's the size that should be received on the other end (I've
read about the returning partial bytes, I can't decode a part of a proto
message, it has to be the right size).

I can't use write_line, I'll have to find a way to delimit the messages
based on size. I think I'll just prepend every message with the size that
it should expect, and then read a integer off the stream and then that many
bytes.

On Tue, Jun 16, 2015 at 11:41 AM, David House <dhouse@janestreet.com> wrote:

> Ah, now I read your code in more detail I think I see why.
>
> Reader.contents on the server side will block until eof. The client side
> sends some stuff, but does not close the writer, so the server never sees
> eof. (Recall that sockets are not like files: it's possible to read all of
> the available data right now, but not reach eof.)
>
> Network protocols normally have some explicit "this is the end of one
> message" marker, like a newline or something similar. Then the server just
> reads chunks until it sees that marker, at which point it can put the
> message together and to something with it.
>
> For example, you could use Writer.write_line on the client side and
> Reader.read_line on the server side.
>
> On 16 June 2015 at 16:36, Kenneth Adam Miller <kennethadammiller@gmail.com
> > wrote:
>
>> So, now I can get server received if I add that into the callback, but at
>> "writing shutdown to server" I don't see response received or even
>> something for Eof.
>>
>> On Tue, Jun 16, 2015 at 11:09 AM, David House <dhouse@janestreet.com>
>> wrote:
>>
>>> The first thing to try is to make sure that everything is getting
>>> flushed. For temporary debugging messages I strongly recommend just using
>>> [Core.Std.eprintf "<message>\n%!"].
>>>
>>> On 16 June 2015 at 16:03, Kenneth Adam Miller <
>>> kennethadammiller@gmail.com> wrote:
>>>
>>>> I'm having trouble with OCaml Async. I wrote a small server with it,
>>>> and right now I'm trying to unit test that server. Here's my code for the
>>>> server:
>>>>
>>>>
>>>> let _main ()=
>>>>   print_endline "Server running";
>>>>   let handler = print_endline in
>>>>   let socket = Tcp.on_port 5554 in
>>>>   let server = Tcp.Server.create socket (fun addr r w ->
>>>>       (Reader.contents r) >>| handler; (Writer.write w "got it")) in
>>>>   server
>>>>
>>>>
>>>>
>>>> In my unit test code I have:
>>>>
>>>> let test_shutdown test_ctxt = Thread_safe.block_on_async_exn (fun () ->
>>>>  (
>>>>       print_endline "test_shutdown";
>>>>       let server = Server._main () in
>>>>       server >>= fun server ->
>>>>       let where = Tcp.to_host_and_port "127.0.0.1" 5554 in
>>>>       Tcp.connect where >>= fun s ->
>>>>         let socket, r, w = s in
>>>>         ignore (Writer.write w "kill");
>>>>         ignore (Writer.flushed w);
>>>>         (Reader.recv r >>> function
>>>>           | `Ok result ->  print_endline ("writing shutdown to server"
>>>> ^ result)
>>>>           | `Eof -> ());
>>>>         return ()
>>>>     )); ()
>>>>
>>>>
>>>>
>>>> I see test_shutdown and Server running, but not sign of "writing
>>>> shutdown to server" or even "got it"; why isn't my server or even any of
>>>> the connection executing?
>>>>
>>>
>>>
>>
>

[-- Attachment #2: Type: text/html, Size: 21534 bytes --]

Re: [Caml-list] Async Server not executing

[Kenneth Adam Miller]

[-- Attachment #1: Type: text/plain, Size: 4030 bytes --]

Ok, I have one last question - I've gotten my unit tests to succeed
properly, but I'm concerned.

At one point in the Pipe documentation, it talked about how writes a recvs
would guarantee progress by returning early if they had something at all. I
just need some kind of guarantee of the semantics of a send and recv, so
that if I send a string of length 4, I don't receive multiple fragments.

On Tue, Jun 16, 2015 at 11:48 AM, Kenneth Adam Miller <
kennethadammiller@gmail.com> wrote:

> Ah. Well I think I can incorporate from that what I can, but my unit tests
> need to be reflective of the use case I have. I'm sending protobuf encoded
> messages between two processes on one machine-whatever the size of the
> message, that's the size that should be received on the other end (I've
> read about the returning partial bytes, I can't decode a part of a proto
> message, it has to be the right size).
>
> I can't use write_line, I'll have to find a way to delimit the messages
> based on size. I think I'll just prepend every message with the size that
> it should expect, and then read a integer off the stream and then that many
> bytes.
>
> On Tue, Jun 16, 2015 at 11:41 AM, David House <dhouse@janestreet.com>
> wrote:
>
>> Ah, now I read your code in more detail I think I see why.
>>
>> Reader.contents on the server side will block until eof. The client side
>> sends some stuff, but does not close the writer, so the server never sees
>> eof. (Recall that sockets are not like files: it's possible to read all of
>> the available data right now, but not reach eof.)
>>
>> Network protocols normally have some explicit "this is the end of one
>> message" marker, like a newline or something similar. Then the server just
>> reads chunks until it sees that marker, at which point it can put the
>> message together and to something with it.
>>
>> For example, you could use Writer.write_line on the client side and
>> Reader.read_line on the server side.
>>
>> On 16 June 2015 at 16:36, Kenneth Adam Miller <
>> kennethadammiller@gmail.com> wrote:
>>
>>> So, now I can get server received if I add that into the callback, but
>>> at "writing shutdown to server" I don't see response received or even
>>> something for Eof.
>>>
>>> On Tue, Jun 16, 2015 at 11:09 AM, David House <dhouse@janestreet.com>
>>> wrote:
>>>
>>>> The first thing to try is to make sure that everything is getting
>>>> flushed. For temporary debugging messages I strongly recommend just using
>>>> [Core.Std.eprintf "<message>\n%!"].
>>>>
>>>> On 16 June 2015 at 16:03, Kenneth Adam Miller <
>>>> kennethadammiller@gmail.com> wrote:
>>>>
>>>>> I'm having trouble with OCaml Async. I wrote a small server with it,
>>>>> and right now I'm trying to unit test that server. Here's my code for the
>>>>> server:
>>>>>
>>>>>
>>>>> let _main ()=
>>>>>   print_endline "Server running";
>>>>>   let handler = print_endline in
>>>>>   let socket = Tcp.on_port 5554 in
>>>>>   let server = Tcp.Server.create socket (fun addr r w ->
>>>>>       (Reader.contents r) >>| handler; (Writer.write w "got it")) in
>>>>>   server
>>>>>
>>>>>
>>>>>
>>>>> In my unit test code I have:
>>>>>
>>>>> let test_shutdown test_ctxt = Thread_safe.block_on_async_exn (fun ()
>>>>> -> (
>>>>>       print_endline "test_shutdown";
>>>>>       let server = Server._main () in
>>>>>       server >>= fun server ->
>>>>>       let where = Tcp.to_host_and_port "127.0.0.1" 5554 in
>>>>>       Tcp.connect where >>= fun s ->
>>>>>         let socket, r, w = s in
>>>>>         ignore (Writer.write w "kill");
>>>>>         ignore (Writer.flushed w);
>>>>>         (Reader.recv r >>> function
>>>>>           | `Ok result ->  print_endline ("writing shutdown to
>>>>> server" ^ result)
>>>>>           | `Eof -> ());
>>>>>         return ()
>>>>>     )); ()
>>>>>
>>>>>
>>>>>
>>>>> I see test_shutdown and Server running, but not sign of "writing
>>>>> shutdown to server" or even "got it"; why isn't my server or even any of
>>>>> the connection executing?
>>>>>
>>>>
>>>>
>>>
>>
>

[-- Attachment #2: Type: text/html, Size: 22382 bytes --]

Re: [Caml-list] Async Server not executing

[David House]

[-- Attachment #1: Type: text/plain, Size: 4848 bytes --]

Right, length-prefixing is another common trick.

In fact, this is exactly what Writer.send does. Your code at the moment is
a little weird because it uses Reader.recv, whose documentation says "[recv
t] returns a string that was written with Writer.send", but you're not
using Writer.send. I think if you use those pairs of things then you get
the semantics you want.

More generally, async has good support for reading chunks of data, which
might contain partial messages, and then putting those chunks together to
form full messages. See Unpack_sequence in async_extra, which works with
Unpack_buffer in core_kernel.

On 16 June 2015 at 18:50, Kenneth Adam Miller <kennethadammiller@gmail.com>
wrote:

> Ok, I have one last question - I've gotten my unit tests to succeed
> properly, but I'm concerned.
>
> At one point in the Pipe documentation, it talked about how writes a recvs
> would guarantee progress by returning early if they had something at all. I
> just need some kind of guarantee of the semantics of a send and recv, so
> that if I send a string of length 4, I don't receive multiple fragments.
>
> On Tue, Jun 16, 2015 at 11:48 AM, Kenneth Adam Miller <
> kennethadammiller@gmail.com> wrote:
>
>> Ah. Well I think I can incorporate from that what I can, but my unit
>> tests need to be reflective of the use case I have. I'm sending protobuf
>> encoded messages between two processes on one machine-whatever the size of
>> the message, that's the size that should be received on the other end (I've
>> read about the returning partial bytes, I can't decode a part of a proto
>> message, it has to be the right size).
>>
>> I can't use write_line, I'll have to find a way to delimit the messages
>> based on size. I think I'll just prepend every message with the size that
>> it should expect, and then read a integer off the stream and then that many
>> bytes.
>>
>> On Tue, Jun 16, 2015 at 11:41 AM, David House <dhouse@janestreet.com>
>> wrote:
>>
>>> Ah, now I read your code in more detail I think I see why.
>>>
>>> Reader.contents on the server side will block until eof. The client side
>>> sends some stuff, but does not close the writer, so the server never sees
>>> eof. (Recall that sockets are not like files: it's possible to read all of
>>> the available data right now, but not reach eof.)
>>>
>>> Network protocols normally have some explicit "this is the end of one
>>> message" marker, like a newline or something similar. Then the server just
>>> reads chunks until it sees that marker, at which point it can put the
>>> message together and to something with it.
>>>
>>> For example, you could use Writer.write_line on the client side and
>>> Reader.read_line on the server side.
>>>
>>> On 16 June 2015 at 16:36, Kenneth Adam Miller <
>>> kennethadammiller@gmail.com> wrote:
>>>
>>>> So, now I can get server received if I add that into the callback, but
>>>> at "writing shutdown to server" I don't see response received or even
>>>> something for Eof.
>>>>
>>>> On Tue, Jun 16, 2015 at 11:09 AM, David House <dhouse@janestreet.com>
>>>> wrote:
>>>>
>>>>> The first thing to try is to make sure that everything is getting
>>>>> flushed. For temporary debugging messages I strongly recommend just using
>>>>> [Core.Std.eprintf "<message>\n%!"].
>>>>>
>>>>> On 16 June 2015 at 16:03, Kenneth Adam Miller <
>>>>> kennethadammiller@gmail.com> wrote:
>>>>>
>>>>>> I'm having trouble with OCaml Async. I wrote a small server with it,
>>>>>> and right now I'm trying to unit test that server. Here's my code for the
>>>>>> server:
>>>>>>
>>>>>>
>>>>>> let _main ()=
>>>>>>   print_endline "Server running";
>>>>>>   let handler = print_endline in
>>>>>>   let socket = Tcp.on_port 5554 in
>>>>>>   let server = Tcp.Server.create socket (fun addr r w ->
>>>>>>       (Reader.contents r) >>| handler; (Writer.write w "got it")) in
>>>>>>   server
>>>>>>
>>>>>>
>>>>>>
>>>>>> In my unit test code I have:
>>>>>>
>>>>>> let test_shutdown test_ctxt = Thread_safe.block_on_async_exn (fun ()
>>>>>> -> (
>>>>>>       print_endline "test_shutdown";
>>>>>>       let server = Server._main () in
>>>>>>       server >>= fun server ->
>>>>>>       let where = Tcp.to_host_and_port "127.0.0.1" 5554 in
>>>>>>       Tcp.connect where >>= fun s ->
>>>>>>         let socket, r, w = s in
>>>>>>         ignore (Writer.write w "kill");
>>>>>>         ignore (Writer.flushed w);
>>>>>>         (Reader.recv r >>> function
>>>>>>           | `Ok result ->  print_endline ("writing shutdown to
>>>>>> server" ^ result)
>>>>>>           | `Eof -> ());
>>>>>>         return ()
>>>>>>     )); ()
>>>>>>
>>>>>>
>>>>>>
>>>>>> I see test_shutdown and Server running, but not sign of "writing
>>>>>> shutdown to server" or even "got it"; why isn't my server or even any of
>>>>>> the connection executing?
>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>
>

[-- Attachment #2: Type: text/html, Size: 23473 bytes --]

Re: [Caml-list] Async Server not executing

[Kenneth Adam Miller]

[-- Attachment #1: Type: text/plain, Size: 5342 bytes --]

I had to change it to make not weird, because I found that because
writer.write wasn't sending the Eof like you said, and it wasn't causally
correct so my code was hanging. I found that out when I got it working
yesterday.

My tests all run normally now! Thank you so so much.

On Wed, Jun 17, 2015 at 4:09 AM, David House <dhouse@janestreet.com> wrote:

> Right, length-prefixing is another common trick.
>
> In fact, this is exactly what Writer.send does. Your code at the moment is
> a little weird because it uses Reader.recv, whose documentation says "[recv
> t] returns a string that was written with Writer.send", but you're not
> using Writer.send. I think if you use those pairs of things then you get
> the semantics you want.
>
> More generally, async has good support for reading chunks of data, which
> might contain partial messages, and then putting those chunks together to
> form full messages. See Unpack_sequence in async_extra, which works with
> Unpack_buffer in core_kernel.
>
> On 16 June 2015 at 18:50, Kenneth Adam Miller <kennethadammiller@gmail.com
> > wrote:
>
>> Ok, I have one last question - I've gotten my unit tests to succeed
>> properly, but I'm concerned.
>>
>> At one point in the Pipe documentation, it talked about how writes a
>> recvs would guarantee progress by returning early if they had something at
>> all. I just need some kind of guarantee of the semantics of a send and
>> recv, so that if I send a string of length 4, I don't receive multiple
>> fragments.
>>
>> On Tue, Jun 16, 2015 at 11:48 AM, Kenneth Adam Miller <
>> kennethadammiller@gmail.com> wrote:
>>
>>> Ah. Well I think I can incorporate from that what I can, but my unit
>>> tests need to be reflective of the use case I have. I'm sending protobuf
>>> encoded messages between two processes on one machine-whatever the size of
>>> the message, that's the size that should be received on the other end (I've
>>> read about the returning partial bytes, I can't decode a part of a proto
>>> message, it has to be the right size).
>>>
>>> I can't use write_line, I'll have to find a way to delimit the messages
>>> based on size. I think I'll just prepend every message with the size that
>>> it should expect, and then read a integer off the stream and then that many
>>> bytes.
>>>
>>> On Tue, Jun 16, 2015 at 11:41 AM, David House <dhouse@janestreet.com>
>>> wrote:
>>>
>>>> Ah, now I read your code in more detail I think I see why.
>>>>
>>>> Reader.contents on the server side will block until eof. The client
>>>> side sends some stuff, but does not close the writer, so the server never
>>>> sees eof. (Recall that sockets are not like files: it's possible to read
>>>> all of the available data right now, but not reach eof.)
>>>>
>>>> Network protocols normally have some explicit "this is the end of one
>>>> message" marker, like a newline or something similar. Then the server just
>>>> reads chunks until it sees that marker, at which point it can put the
>>>> message together and to something with it.
>>>>
>>>> For example, you could use Writer.write_line on the client side and
>>>> Reader.read_line on the server side.
>>>>
>>>> On 16 June 2015 at 16:36, Kenneth Adam Miller <
>>>> kennethadammiller@gmail.com> wrote:
>>>>
>>>>> So, now I can get server received if I add that into the callback, but
>>>>> at "writing shutdown to server" I don't see response received or even
>>>>> something for Eof.
>>>>>
>>>>> On Tue, Jun 16, 2015 at 11:09 AM, David House <dhouse@janestreet.com>
>>>>> wrote:
>>>>>
>>>>>> The first thing to try is to make sure that everything is getting
>>>>>> flushed. For temporary debugging messages I strongly recommend just using
>>>>>> [Core.Std.eprintf "<message>\n%!"].
>>>>>>
>>>>>> On 16 June 2015 at 16:03, Kenneth Adam Miller <
>>>>>> kennethadammiller@gmail.com> wrote:
>>>>>>
>>>>>>> I'm having trouble with OCaml Async. I wrote a small server with it,
>>>>>>> and right now I'm trying to unit test that server. Here's my code for the
>>>>>>> server:
>>>>>>>
>>>>>>>
>>>>>>> let _main ()=
>>>>>>>   print_endline "Server running";
>>>>>>>   let handler = print_endline in
>>>>>>>   let socket = Tcp.on_port 5554 in
>>>>>>>   let server = Tcp.Server.create socket (fun addr r w ->
>>>>>>>       (Reader.contents r) >>| handler; (Writer.write w "got it")) in
>>>>>>>   server
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> In my unit test code I have:
>>>>>>>
>>>>>>> let test_shutdown test_ctxt = Thread_safe.block_on_async_exn (fun ()
>>>>>>>  -> (
>>>>>>>       print_endline "test_shutdown";
>>>>>>>       let server = Server._main () in
>>>>>>>       server >>= fun server ->
>>>>>>>       let where = Tcp.to_host_and_port "127.0.0.1" 5554 in
>>>>>>>       Tcp.connect where >>= fun s ->
>>>>>>>         let socket, r, w = s in
>>>>>>>         ignore (Writer.write w "kill");
>>>>>>>         ignore (Writer.flushed w);
>>>>>>>         (Reader.recv r >>> function
>>>>>>>           | `Ok result ->  print_endline ("writing shutdown to
>>>>>>> server" ^ result)
>>>>>>>           | `Eof -> ());
>>>>>>>         return ()
>>>>>>>     )); ()
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> I see test_shutdown and Server running, but not sign of "writing
>>>>>>> shutdown to server" or even "got it"; why isn't my server or even any of
>>>>>>> the connection executing?
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>
>>>
>>
>

[-- Attachment #2: Type: text/html, Size: 24178 bytes --]