proper auto-reconnection from sockets

Hi Jan,

Here’s how we do the connection / reconnection to sockets in F#:

        let rec subscribeToTrades () =
            let r =
                socketClient.SubscribeToAggregatedTradeUpdatesAsync(symbol, fun trade -> tradesProcessor.Post(trade))
                |> Async.AwaitTask
                |> Async.RunSynchronously
            if not r.Success then failwithf "couldn't subscribe to trades updates -  %i:%s" r.Error.Code r.Error.Message
            else
                r.Data.add_ConnectionLost     (fun _ -> eprintfn "%A - trades socket connection lost" DateTime.UtcNow)
                r.Data.add_ConnectionRestored (fun _ -> eprintfn "%A - trades socket connection restored" DateTime.UtcNow
                                                        subscribeToTrades())

as you wrote the lib, could you confirm if this is optimal, or if there would be something you’d do differently when it comes to the subscription / reconnection mechanism?

[JKorf]

No, listenkey should indeed be handled manually. The advise is to call KeepAlive every 30 minutes, but I don’t think there is any downside to calling it every 10 minutes. I think you only get the listen key expired after 60 minutes without keep alive, so you shouldn’t run into that.

Looks just fine the way you’re handling it.

[thomasd3]

actually a related question: do you handle the listen key directly too, for the SubscribeToUserDataUpdatesAsync call?

right now I resubscribe when if the license key is expired.

I do something like this:

       // get the user data updates
        let rec subscribeToUserDataUpdates () =
            // get the user data
            listenKey <-
                (
                    restClient.StartUserStreamAsync()
                    |> Async.AwaitTask
                    |> Async.RunSynchronously
                ).Data

            let r =
                socketClient.SubscribeToUserDataUpdatesAsync
                    (
                        listenKey,
                        (fun _ -> ()),                                          // cross wallet update
                        (fun _ -> ()),                                          // margin update
                        (fun balances  -> balancesProcessor.Post(balances)),    // balances
                        (fun positions -> positionsProcessor.Post(positions)),  // positions
                        (fun order     -> ordersProcessor.Post(order)),         // orders
                        (fun _         -> subscribeToUserDataUpdates())         // listenKey expired
                    )
                    |> Async.AwaitTask
                    |> Async.RunSynchronously
            if not r.Success then failwithf "couldn't subscribe to user data updates -  %i:%s" r.Error.Code r.Error.Message
            else
                r.Data.add_ConnectionLost     (fun _ -> eprintfn "%A - user data socket connection lost" DateTime.UtcNow)
                r.Data.add_ConnectionRestored (fun _ -> eprintfn "%A - user data socket connection restored" DateTime.UtcNow
                                                        subscribeToUserDataUpdates())

I also have this that goes with it:

        // set the listenkey timer
        let updateTimerInterval = TimeSpan.FromMinutes(10.)
        listenKeyTimer.Elapsed.Add (fun _ ->
            restClient.KeepAliveUserStreamAsync(listenKey)
            |> Async.AwaitTask
            |> Async.RunSynchronously
            |> ignore)
        listenKeyTimer.Interval <- updateTimerInterval.TotalMilliseconds
        listenKeyTimer.Enabled  <- true
        listenKeyTimer.Start()