protected ClientPeer(ILog logger, INetworkMessageRouterService messageSender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler #if !ENDUSER , INetworkMessageRouteBackService routebackService) #else ) #endif : base(logger, messageSender, details, subService, disconnectHandler)
public InstanceClientSession(ILog logger, INetworkMessagePayloadSenderService sender, IConnectionDetails details,
INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler, IRequestMessageHandlerService <InstanceClientSession> requestMessageHandlers)
: base(logger, sender, details, subService, disconnectHandler)
{
if (requestMessageHandlers == null)
{
throw new ArgumentNullException(nameof(requestMessageHandlers), $"Cannot provide a null {nameof(IRequestMessageHandlerService<InstanceClientSession>)}.");
}
requestMessageHandlerService = requestMessageHandlers;
}
/// <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;
}
protected Peer(ILog logger, INetworkMessageRouterService messageSender, IConnectionDetails details, INetworkMessageSubscriptionService subService,
IDisconnectionServiceHandler disconnectHandler)
{
Throw<ArgumentNullException>.If.IsNull(logger)?.Now(nameof(logger));
Throw<ArgumentNullException>.If.IsNull(messageSender)?.Now(nameof(messageSender));
Throw<ArgumentNullException>.If.IsNull(details)?.Now(nameof(details));
Throw<ArgumentNullException>.If.IsNull(subService)?.Now(nameof(subService));
Throw<ArgumentNullException>.If.IsNull(disconnectHandler)?.Now(nameof(disconnectHandler));
PeerDetails = details;
NetworkSendService = messageSender;
Logger = logger;
disconnectionHandler = disconnectHandler;
//All peers should care about status changes so we subscribe
subService.SubscribeTo<StatusMessage>()
.With(OnReceiveStatus);
}
//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 UserClientPeerSession(ILog logger, INetworkMessageSender sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler)
: base(logger, sender, details, subService, disconnectHandler)
{
logger.Debug("Created new client session.");
}
/// <inheritdoc />
public override ClientPeerSession CreateIncomingPeerSession(INetworkMessagePayloadSenderService sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler)
{
//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, 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);
}
//Resolves a TSessionType from the context provided
private TSessionType SessionResolve <TSessionType>(IComponentContext context, INetworkMessageSender sender, IConnectionDetails details,
INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler)
where TSessionType : ClientPeerSession
{
return(context.Resolve <TSessionType>(GenerateTypedParameter(sender), GenerateTypedParameter(details), GenerateTypedParameter(subService), GenerateTypedParameter(disconnectHandler)));
}
public AuthServicePeerSession(ILog logger, INetworkMessageSender sender, IConnectionDetails details, INetworkMessageSubscriptionService netMessageSubService,
IDisconnectionServiceHandler disconnectHandler, IRequestPayloadHandlerService <AuthServicePeerSession> requestHandlerService)
: base(logger, sender, details, netMessageSubService, disconnectHandler)
{
logger.Debug("Created new authservice.");
requestHandler = requestHandlerService;
}
/// <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 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);
public ClientPeerSession Create(INetworkMessageSender sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler)
{
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));
//return userPeerFactory(GenerateTypedParameter(sender), GenerateTypedParameter(details), GenerateTypedParameter(subService), GenerateTypedParameter(disconnectHandler));
case ProxySessionType.AuthServiceSession:
Logger.Debug("Creating new un-authenticated authservice session.");
return(authPeerFactory(sender, details, subService, disconnectHandler));
case ProxySessionType.Default:
default:
Logger.ErrorFormat("An invalid {0} was generated from Port: {1}", nameof(ProxySessionType), details.LocalPort);
return(null);
}
}
public override ServerPeerSession CreateServerPeerSession(INetworkMessageSender sender, IConnectionDetails details, INetworkMessageSubscriptionService subService, IDisconnectionServiceHandler disconnectHandler)
{
throw new NotImplementedException("This is deprecated and will be removed. Somehow a someone tried to create a peer session.");
}
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);
}
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 a game server session.
/// </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 GameServicePeerSession(ILog logger, INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService netMessageSubService,
IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService, IRequestMessageHandlerService <GameServicePeerSession> requestHandler)
: base(logger, sender, details, netMessageSubService, 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 a new gameserver service peer session.");
requestHandlerService = requestHandler;
}
public ServerPeerSession(ILog logger, INetworkMessageRouterService sender, IConnectionDetails details, INetworkMessageSubscriptionService netMessageSubService,
IDisconnectionServiceHandler disconnectHandler, INetworkMessageRouteBackService routebackService)
: base(logger, sender, details, netMessageSubService, disconnectHandler, routebackService)
{
}
