C#MS custom events may not recover after gateway rolling

[cdhanna]

When C#MS is subscribed to custom events, if gateway dies, then the service stops receiving events.
The subscription is not being re-established.

When the websocket connection re-establishes, it does not appear that the custom event service is being re-initialized.

The [InitializeServices] attribute only runs once on service startup. We need a better more-robust way to re-run the custom logic.

[cdhanna]

We should start by validating that the custom event stuff gets re-run after a websocket death.
Then, we should figure out how to get the reconnection logic to run with the custom handling.

[cdhanna]

For a customer, we may need to back-patch to 4.3.x

[cdhanna]

this seems to do the trick.

using System;
using Beamable.Server;
using System.Threading.Tasks;
using Beamable.Common;
using Beamable.Common.Api;
using Beamable.Common.Dependencies;
using Beamable.Server.Api.RealmConfig;
using UnityEngine;

namespace Beamable.Tunafish
{
	public class Program
	{
		private const string EVT = "realm-config.refresh";
		/// <summary>
		/// The entry point for the <see cref="Tunafish"/> service.
		/// </summary>
		public static async Task Main()
		{
			await BeamServer
				.Create()
				.ConfigureServices(b => AddCallbackAfterReconnection(b, InitializeSubscription))
				.InitializeServices(async services =>
				{
					Debug.Log("I am running!");
					await InitializeSubscription(services);
					var socket = services.GetService<SocketRequesterContext>();
					socket.Subscribe<object>(EVT, _ =>
					{
						Debug.Log("config refresh received!");
					});
				})
				.IncludeRoutes<Tunafish>(routePrefix: "")
				.DisableAllBeamableEvents()
				
				.RunForever();
		}
		
		public static async Promise InitializeSubscription(IDependencyProvider provider)
		{
			var requester = provider.GetService<IBeamableRequester>();

			var req = new MicroserviceEventProviderRequest
			{
				type = "event",
				evtWhitelist = new []
				{ 
					EVT
				}
			};
			Debug.Log("Custom event subs");
			await requester.Request<MicroserviceProviderResponse>(Method.POST, "gateway/provider", req);
		}


		public static void AddCallbackAfterReconnection(IDependencyBuilder builder, Func<IDependencyProvider, Promise> reconnectionCallback)
		{
			var raw = builder as DependencyBuilder;

			if (raw == null || !raw.TryGetSingleton(typeof(IRealmConfigService), out var desc))
			{
				Log.Error("Unable to add reconnection callback because the given builder was not the expected concrete type.");
			}
			else
			{
				var lockObject = new object();
				IRealmConfigService instance = null;
				
				builder.Remove<IRealmConfigService>();
				builder.AddSingleton(provider =>
				{
					var ctx = provider.GetService<SocketRequesterContext>();
					
					lock (lockObject)
					{
						if (instance == null)
						{
							instance = (IRealmConfigService)desc.Factory(provider);
							
							var conn = ctx.Socket.IsCompleted ? ctx.Socket.GetResult() as EasyWebSocket : null;
							if (conn == null) return instance;
							
							conn.OnDisconnect((_, wasClean) =>
							{
								if (!wasClean)
								{
									// the unclean disconnects are the ones where the websocket cannot be re-used
									reconnectionCallback(provider).Error(Debug.LogException);
								}
							});
							
						}
					}
					return instance;
				});
			}
		}
	}
	
}