12:13 <SeanTAllen> A new "Last Week in Pony" is out: https://www.ponylang.org/blog/2017/06/last-week-in-pony---june-4-2017/

19:11 <endformationage> Is there a way to stop Timers such that it will allow a program to end without requiring termination?

19:12 <endformationage> I tried to send the dispose() message to timers from a notifier's cancel callback, but it still ran.

19:18 <SeanTAllen> can you gist the code that you use to dispose endformationage ?

19:19 <SeanTAllen> are you sending a cancel message to the Timers object endformationage ?

19:20 <SeanTAllen> note that dispose does not cancel any a Timer

19:20 <SeanTAllen> it only disposes of the timing wheel

19:30 <endformationage> I returned false in a TimerNotify apply call, and the notifier's cancel does get called. From there I've tried dispose() on the `timers` wheels as closed upon, as well as via a behavior back on the Main actor where the wheels live.

19:34 <jemc> `Timers.dispose()` should be enough - you shouldn't need to also cancel the individual timers

19:34 <SeanTAllen> I'm confused by that description

19:34 <SeanTAllen> Can you gist the code?

19:34 <endformationage> Right, putting together a simplified example.

19:34 <endformationage> ..

19:35 <jemc> I'm guessing that either 1) dispose isn't actually getting called, or 2) you have another "noisy" actor keeping your program from hitting quiesence

19:37 <SeanTAllen> that would be my theory as well

19:37 <SeanTAllen> but i also suspect that perhaps i am not understanding the problem correctly

19:37 <SeanTAllen> when in doubt, i assume my understand is incorrect

19:43 <endformationage> Lol, the example I just came up with behaved as expected..

19:44 <jemc> endformationage: so to test my two theories:

19:44 <jemc> 1) add a `Debug` statement right after you call `Timers.dispose`

19:45 <SeanTAllen> endformationage: how large is your non-simplified code?

19:46 <jemc> 2) ask yourself if there are any other "noisy" actors running - anything that "generates" messages from scratch like `Timers`, or gets input from outside the program like `TCPConnection`

19:48 <endformationage> jemc: yeah, using net/HTTP

19:50 <SeanTAllen> endformationage: incoming or outgoing?

19:51 <jemc> endformationage: make sure any actors with a `dispose` method are getting it called - if necessary, use a `Custodian` https://stdlib.ponylang.org/bureaucracy-Custodian/

19:52 <endformationage> Incoming. Though, I had put the same code run by the timer in it's own function, called strait away the program completes fine.

19:52 <SeanTAllen> are you shutting down the HTTP server endformationage ?

19:53 <endformationage> Excuse me, I meant client requests

19:53 <SeanTAllen> ok, those outgoing requests create tcp connections that need to be shutdown

19:54 <endformationage> .. and the session is disposed when finished is called on the handler

19:56 <endformationage> BTW, The program completes fine after requests without the use of timers.

19:58 <SeanTAllen> sounds like there is something else going on other than what you've mentioned so far then

19:59 <SeanTAllen> without seeing code, its basically just guessing from this end.

20:11 <endformationage> Yeah, must be something to do with the HTTPClient and sessions, as I just ran my example without disposing timers and program still completed.

20:14 <endformationage> Odd though that I can run the same requests (without being wrapped and delayed by a timer) and program will complete.

20:15 <endformationage> jemc: SeanTAllen: are there any articles where I can learn more about quiesence in Pony? Or does it pretty much boil down to dispose of 'generating' actors?

20:17 <jemc> I don't know if much has been written about it, but it boils down to Pony making a determination that no actors in your program will ever be able to receive more messages in the future, which is determined by two factors:

20:19 <jemc> 1) if there are any messages already in flight, then those messages could cause new messages to that actor, or any other actor that the actor can "reach" (has a reference to)

20:20 <jemc> 2) if an actor has a subscription to Pony's underlying asynchronous I/O engine (shortened as "asio", but not to be confused with the popular unix audio engine by the same name), then that actor can receive new messages at any time from I/O

20:22 <jemc> the latter kind of actor is referred to as being "noisy", since as long as it is subscribed to the asio engine, the program cannot be quiescent

20:22 <endformationage> jemc: Thanks, that is very helpful. In fact this short description should go into the tutorial I feel.

20:23 <jemc> the key thing that needs to happen is the C FFI call to `@pony_asio_event_unsubscribe`, which is what `dispose` on a noisy actor ultimately does

20:23 <jemc> endformationage: yes, you're probably right that it should be in the tutorial somewhere

20:28 <endformationage> 1 makes me wonder if there's any way to see what messages are pending for actors to process? 2 makes me think of the SSLContext carried by the HTTPClient, which looks like it has a dispose fun

20:29 <endformationage> HTTPClient does not however.

20:30 <endformationage> SeanTAllen: jemc: Thanks for the help, will toy with it more after lunch!

22:38 <SeanTAllen> endformationage: re: 1- no there isn't

22:38 <SeanTAllen> _ClientConnection that is stored in HTTPClient, each one of those has a TCPConnection associated with it that needs to be shutdown.

22:39 <SeanTAllen> I'd suggest dropping some debugs in key points in the standard library classes to make sure things you expect are getting shutdown are (like, close() is being called on your TCPConnections)