//Message responses are dispatched right after requests with this strategy. This is much different
//than what is normally found in GladNet2 implementations.
/// <summary>
/// Creates a new <see cref="IWebRequestEnqueueStrategy"/> that handles requests on the calling thread
/// and blocks.
/// </summary>
/// <param name="baseURL">Base string for the end-poind webserver. (Ex. www.google.com/)</param>
/// <param name="deserializationService">Deserialization strategy for responses.</param>
/// <param name="responseReciever">Message receiver service for dispatching recieved resposne messages.</param>
public RestSharpCurrentThreadEnqueueRequestHandlerStrategy(string baseURL, IDeserializerStrategy deserializationService, ISerializerStrategy serializerStrategy, INetworkMessageReceiver responseReciever, int connectionAUID
#if !ENDUSER
, INetworkMessageRouteBackService routebackService) //unfortunaly the single-threaded blocking enqueue strat needs the routeback service to function.
#endif
{
if (String.IsNullOrEmpty(baseURL))
throw new ArgumentException($"Parameter {baseURL} is not valid. Either null or empty. Base URL must be the base URL of the web server. (Ex. www.google.com)");
if (deserializationService == null)
throw new ArgumentNullException(nameof(baseURL), $"Parameter {deserializationService} must not be null. Deserialization for incoming responses is required.");
#if !ENDUSER
if (routebackService == null)
throw new ArgumentNullException(nameof(routebackService), $"{nameof(RestSharpCurrentThreadEnqueueRequestHandlerStrategy)} requires {(nameof(INetworkMessageRouteBackService))} as it handles responses too.");
#endif
serializer = serializerStrategy;
deserializer = deserializationService;
responseMessageRecieverService = responseReciever;
restsharpMiddlewares = new List<IRestSharpMiddleWare>(2);
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls;
httpClient = new RestClient(baseURL) { Timeout = 15000 };
#if !ENDUSER
messageRoutebackService = routebackService;
#endif
}
protected ClientPeer(ILog logger, INetworkMessageRouterService messageSender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler #if !ENDUSER , INetworkMessageRouteBackService routebackService) #else ) #endif : base(logger, messageSender, details, subService, disconnectHandler)
/// <summary>
/// Creates a new object that represents a client/user connection.
/// </summary>
/// <param name="logger">Logging service for this session.</param>
/// <param name="sender">Network message sending service.</param>
/// <param name="details">Connection details for this specific incoming game server session.</param>
/// <param name="netMessageSubService">Subscription service for incoming messages.</param>
/// <param name="disconnectHandler">Disconnection handler for the session.</param>
/// <param name="requestHandler">Request payload handler for the session.</param>
public UserClientPeerSession(ILog logger, INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler,
INetworkMessageRouteBackService routebackService, IRequestMessageHandlerService <UserClientPeerSession> requestHandler)
: base(logger, sender, details, subService, disconnectHandler, routebackService)
{
//We check logger null because we want to log now
Throw <ArgumentNullException> .If.IsNull(logger)?.Now(nameof(logger), $"Logging service provided must be non-null.");
Throw <ArgumentNullException> .If.IsNull(requestHandler)?.Now(nameof(requestHandler), $"Request handling service provided must be non-null.");
logger.Debug("Created new client session.");
requestHandlerService = requestHandler;
}
//Resolves a TSessionType from the context provided
private TSessionType SessionResolve <TSessionType>(IComponentContext context, INetworkMessageRouterService sender, IConnectionDetails details,
INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routeBackService)
where TSessionType : ClientPeerSession
{
return(context.Resolve <TSessionType>(GenerateTypedParameter(sender), GenerateTypedParameter(details), GenerateTypedParameter(subService), GenerateTypedParameter(disconnectHandler), GenerateTypedParameter(routeBackService)));
}
/// <summary>
/// Creates a server client session (outbound) for the incoming connection request.
/// </summary>
/// <param name="sender">Message sending service.</param>
/// <param name="details">Connection details.</param>
/// <param name="subService">Subscription service for networked messages.</param>
/// <param name="disconnectHandler">Disconnection handling service.</param>
/// <returns>A new client session.</returns>
public abstract GladNet.Engine.Common.ClientPeer CreateServerPeer(INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService,
IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService);
/// <summary>
/// Creates a client session for the incoming connection request.
/// </summary>
/// <param name="sender">Message sending service.</param>
/// <param name="details">Connection details.</param>
/// <param name="subService">Subscription service for networked messages.</param>
/// <param name="disconnectHandler">Disconnection handling service.</param>
/// <returns>A new client session.</returns>
protected abstract ClientPeerSession CreateClientSession(INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService,
IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService);
//Right now there isn't anything extra in a Lidgren peer. It needs to be used so that it
//can be a future vector for delivering features to lidgren peers.
public LidgrenClientPeer(ILog logger, INetworkMessageRouterService messageSender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService)
: base(logger, messageSender, details, subService, disconnectHandler, routebackService)
{
}
public InstanceClientSession(ILog logger, INetworkMessageRouterService sender, IConnectionDetails details,
INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService,
IRequestMessageHandlerService <InstanceClientSession> requestMessageHandlers)
: base(logger, sender, details, subService, disconnectHandler, routebackService)
{
if (requestMessageHandlers == null)
{
throw new ArgumentNullException(nameof(requestMessageHandlers), $"Cannot provide a null {nameof(IRequestMessageHandlerService<InstanceClientSession>)}.");
}
requestMessageHandlerService = requestMessageHandlers;
}
protected override ClientPeerSession CreateIncomingPeerSession(INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService)
{
//For now we assume that any connection is valid.
//In the future we might filter out some IPs but most validation will be post-connection from a signed message.
ClientPeerSession session = new InstanceClientSession(Logger, sender, details, subService, disconnectHandler, routebackService, instanceSessionRequestMessageHandlerService);
//Register the OnDisconnect UnityEvent for when the session disconnects
disconnectHandler.DisconnectionEventHandler += () => OnSessionDisconnected?.Invoke(session);
//This isn't great; invoking this before returning it to the server base is not great design but it's the only way right now
OnNewSessionCreated?.Invoke(session);
return(session);
}
public ServerPeerSession(ILog logger, INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService netMessageSubService,
IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService)
: base(logger, sender, details, netMessageSubService, disconnectHandler, routebackService)
{
}
protected override ClientPeerSession CreateClientSession(INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routeBack)
{
return(peerFactory.Create(sender, details, subService, disconnectHandler, routeBack));
}
//Right now there isn't anything extra in a Lidgren peer. It needs to be used so that it
//can be a future vector for delivering features to lidgren peers.
public LidgrenClientPeer(ILog logger, INetworkMessageRouterService messageSender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService)
: base(logger, messageSender, details, subService, disconnectHandler, routebackService)
{
}
/// <summary> /// Creates a server client session (outbound) for the incoming connection request. /// </summary> /// <param name="sender">Message sending service.</param> /// <param name="details">Connection details.</param> /// <param name="subService">Subscription service for networked messages.</param> /// <param name="disconnectHandler">Disconnection handling service.</param> /// <returns>A new client session.</returns> public abstract GladNet.Engine.Common.ClientPeer CreateServerPeer(INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService);
/// <summary> /// Creates a client session for the incoming connection request. /// </summary> /// <param name="sender">Message sending service.</param> /// <param name="details">Connection details.</param> /// <param name="subService">Subscription service for networked messages.</param> /// <param name="disconnectHandler">Disconnection handling service.</param> /// <returns>A new client session.</returns> protected abstract ClientPeerSession CreateClientSession(INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService);
/// <summary>
/// Creates a new object that represents an auth service connection.
/// </summary>
/// <param name="logger">Logging service for this session.</param>
/// <param name="sender">Network message sending service.</param>
/// <param name="details">Connection details for this specific incoming game server session.</param>
/// <param name="netMessageSubService">Subscription service for incoming messages.</param>
/// <param name="disconnectHandler">Disconnection handler for the session.</param>
/// <param name="responseHandler">Request payload handler for the session.</param>
public AuthServiceClientPeer(ILog logger, INetworkMessageRouterService messageSender, IConnectionDetails details,
INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService, IResponseMessageHandlerService <AuthServiceClientPeer> responseHandler)
: base(logger, messageSender, details, subService, disconnectHandler, routebackService)
{
//We check logger null because we want to log now
Throw <ArgumentNullException> .If.IsNull(logger)?.Now(nameof(logger), $"Logging service provided must be non-null.");
Throw <ArgumentNullException> .If.IsNull(responseHandler)?.Now(nameof(responseHandler), $"Response handling service provided must be non-null.");
//the authservice doesn't really 'connect'
logger.Debug($"An {nameof(AuthServiceClientPeer)} was created but not connected yet.");
//We only have a response handler; we won't be provided with an event handler (maybe in the future) because we don't want to handle any events.
responseHandlerService = responseHandler;
}
public ClientPeerSession Create(INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routeBack)
{
Logger.DebugFormat("Client trying to create session on Port: {0}", details.LocalPort);
switch (portToSessionTypeConverter.ToSessionType(details.LocalPort))
{
case ProxySessionType.UserSession:
Logger.Debug("Creating client session.");
return(userPeerFactory(sender, details, subService, disconnectHandler, routeBack));
//return userPeerFactory(GenerateTypedParameter(sender), GenerateTypedParameter(details), GenerateTypedParameter(subService), GenerateTypedParameter(disconnectHandler));
case ProxySessionType.GameServiceSession:
Logger.Debug("Creating new un-authenticated authservice session.");
return(authPeerFactory(sender, details, subService, disconnectHandler, routeBack));
case ProxySessionType.Default:
default:
Logger.ErrorFormat("An invalid {0} was generated from Port: {1}", nameof(ProxySessionType), details.LocalPort);
return(null);
}
}
public override ClientPeer CreateServerPeer(INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routeBack)
{
//This shouldn't be called by the ProxyLoadBalancing server
AppLogger.ErrorFormat("Outgoing connection attempt on Proxy to IP {0} Port {1}. Proxy should not be connecting to other peers", details.RemoteIP, details.RemotePort);
return(null);
}
