private void OnStateChanged(object sender, AudioSessionStateChangedEventArgs e)
{
if (e.NewState != AudioSessionState.AudioSessionStateExpired)
{
return;
}
SessionEnded?.Invoke(this);
}
void IAudioSessionEventsHandler.OnStateChanged(AudioSessionState state)
{
if (state != AudioSessionState.AudioSessionStateExpired)
{
return;
}
SessionEnded?.Invoke(this);
}
public void UpdateSessionBasics(SessionType type, SessionPhase phase)
{
if (phase == SessionPhase.None)
{
return;
}
if (_session == null)
{
_session = CreateSession(type);
Logger.Log($"{type} session started - new weekend");
SessionStarted?.Invoke(this, EventArgs.Empty);
}
else if (type != _session.Type)
{
if (IsInProgress(_session.Phase))
{
EndTimedPhase();
}
Logger.Log($"{_session.Type} session ended");
SessionEnded?.Invoke(this, EventArgs.Empty);
var isPartOfWeekend = type > _session.Type;
_session = isPartOfWeekend
? CreateSession(type, _session.WeekendId)
: CreateSession(type);
var message = isPartOfWeekend
? $"{type} session started - part of existing weekend"
: $"{type} session started - new weekend";
Logger.Log(message, Severity.Verbose);
SessionStarted?.Invoke(this, EventArgs.Empty);
}
// We capture this so we the nested methods can use the up-to-date session
var oldPhase = _session.Phase;
_session.UpdateSessionInfo(type, phase);
// If we are in the same session, check if we are advancing through the timed phases
if (type == _session.Type)
{
if (IsStarting(oldPhase) && IsInProgress(_session.Phase))
{
StartTimedPhase();
}
if (IsInProgress(oldPhase) && IsEnding(_session.Phase))
{
EndTimedPhase();
}
}
}
private void TriggerEvents(bool recursive)
{
int originalCount = eventQueue.Count;
// Do not use foreach as eventQueue might change
for (int i = 0; i < (recursive ? eventQueue.Count : originalCount); i++)
{
// Performance is not a problem since events are rare!
var arg = eventQueue[i];
if (arg is GamerJoinedEventArgs)
{
if (GamerJoined != null)
{
GamerJoined.Invoke(this, arg as GamerJoinedEventArgs);
}
}
else if (arg is GamerLeftEventArgs)
{
if (GamerLeft != null)
{
GamerLeft.Invoke(this, arg as GamerLeftEventArgs);
}
}
else if (arg is GameStartedEventArgs)
{
if (GameStarted != null)
{
GameStarted.Invoke(this, arg as GameStartedEventArgs);
}
}
else if (arg is GameEndedEventArgs)
{
if (GameEnded != null)
{
GameEnded.Invoke(this, arg as GameEndedEventArgs);
}
}
else if (arg is NetworkSessionEndedEventArgs)
{
if (SessionEnded != null)
{
SessionEnded.Invoke(this, arg as NetworkSessionEndedEventArgs);
}
}
}
if (recursive)
{
eventQueue.Clear();
}
else
{
eventQueue.RemoveRange(0, originalCount);
}
}
private void OnSessionEnded(IAudioSession session)
{
if (!_sessions.Remove(session.ID))
{
return;
}
session.SessionEnded -= OnSessionEnded;
session.VolumeChanged -= OnSessionVolumeChanged;
session.Dispose();
SessionEnded?.Invoke(session);
}
public SessionManager(Option <ICluster> cluster, SystemName system, ProcessName nodeName, VectorConflictStrategy strategy)
{
this.cluster = cluster;
this.system = system;
this.nodeName = nodeName;
Sync = new SessionSync(system, nodeName, strategy);
cluster.Iter(c =>
{
notify = c.SubscribeToChannel <SessionAction>(SessionsNotify).Subscribe(act => Sync.Incoming(act));
var now = DateTime.UtcNow;
// Look for stranded sessions that haven't been removed properly. This is done once only
// on startup because the systems should be shutting down sessions on their own. This just
// catches the situation where an app-domain died without shutting down properly.
c.GetAllHashFieldsInBatch(c.QuerySessionKeys().ToSeq())
.Map(sessions =>
sessions.Filter(vals => (from ts in vals.Find(LastAccessKey).Map(v => new DateTime((long)v))
from to in vals.Find(TimeoutKey).Map(v => (long)v)
where ts < now.AddSeconds(-to * 2)
select true).IfNone(false))
.Keys)
.Map(Seq)
.Do(strandedSessions => SupplementarySessionManager.removeSessionIdFromSuppMap(c, strandedSessions.Map(ReverseSessionKey)))
.Do(strandedSessions => c.DeleteMany(strandedSessions))
.Map(strandedSessions => strandedSessions.Iter(sessionId => c.PublishToChannel(SessionsNotify, SessionAction.Stop(sessionId, system, nodeName))));;
// Remove session keys when an in-memory session ends
ended = SessionEnded.Subscribe(sid => Stop(sid));
touch = Sync.Touched.Subscribe(tup =>
{
try
{
//check if the session has not been stopped in the meantime or expired
if (c.HashFieldAddOrUpdateIfKeyExists(SessionKey(tup.Item1), LastAccessKey, DateTime.UtcNow.Ticks))
{
c.PublishToChannel(SessionsNotify, SessionAction.Touch(tup.Item1, system, nodeName));
}
}
catch (Exception e)
{
logErr(e);
}
});
});
}
public void Remove(IGameSession session)
{
if (session == null)
{
return;
}
lock (sessionMutex)
{
if (sessions.Remove(session))
{
if (SessionEnded != null)
{
SessionEnded.Invoke(this, session);
}
}
}
}
/// <summary>
/// Ends the specified <see cref="Session"/>.
/// </summary>
/// <param name="session">The Session to end.</param>
/// <returns>A Result containing the result of the operation.</returns>
public IResult EndSession(ISession session)
{
logger.EnterMethod();
logger.Debug($"Ending Session '{session?.Token}'...");
IResult retVal = new Result();
ISession foundSession = default(Session);
if (State != State.Running)
{
retVal.AddError($"The Manager is not in a state in which it can service requests (Currently {State}).");
}
else
{
foundSession = FindSession(session?.Token);
if (foundSession != default(Session))
{
sessionLock.EnterWriteLock();
try
{
SessionList.Remove(foundSession);
}
finally
{
sessionLock.ExitWriteLock();
}
}
else
{
retVal.AddError($"The Session matching Token '{session?.Token}' does not exist.");
}
}
if (retVal.ResultCode != ResultCode.Failure)
{
Task.Run(() => SessionEnded?.Invoke(this, new SessionEventArgs(foundSession)));
}
retVal.LogResult(logger.Debug);
logger.ExitMethod();
return(retVal);
}
public SessionManager(Option <ICluster> cluster, SystemName system, ProcessName nodeName, VectorConflictStrategy strategy)
{
this.cluster = cluster;
this.system = system;
this.nodeName = nodeName;
Sync = new SessionSync(system, nodeName, strategy);
cluster.Iter(c =>
{
notify = c.SubscribeToChannel <SessionAction>(SessionsNotify).Subscribe(act => Sync.Incoming(act));
var now = DateTime.UtcNow;
// Look for stranded sessions that haven't been removed properly. This is done once only
// on startup because the systems should be shutting down sessions on their own. This just
// catches the situation where an app-domain died without shutting down properly.
c.QuerySessionKeys()
.Map(key =>
from ts in c.GetHashField <long>(key, LastAccessKey)
from to in c.GetHashField <int>(key, TimeoutKey)
where new DateTime(ts) < now.AddSeconds(-to * 2) // Multiply by 2, just to catch genuine non-active sessions
select c.Delete(key))
.Iter(id => { });
// Remove session keys when an in-memory session ends
ended = SessionEnded.Subscribe(sid => Stop(sid));
touch = Sync.Touched.Subscribe(tup =>
{
try
{
c.HashFieldAddOrUpdate(SessionKey(tup.Item1), LastAccessKey, DateTime.UtcNow.Ticks);
c.PublishToChannel(SessionsNotify, SessionAction.Touch(tup.Item1, system, nodeName));
}
catch (Exception e)
{
logErr(e);
}
});
});
}
/// <summary>
/// handles a sessioninfo packet
/// </summary>
private void handlesessioninfo()
{
headers.infotype infotype = headers.infotypes[sendrecv.readfromstream(_Reader, 1)[0]]; //first get the infotype of the sessioninfopacket
//handle the packet depending on the type of the packet
switch (infotype)
{
case headers.infotype.CurrentSessionInfo:
Int32 idlength = BitConverter.ToInt32(sendrecv.readfromstream(_Reader, 4), 0);
string id = Encoding.UTF8.GetString(sendrecv.readfromstream(_Reader, idlength));
byte role = sendrecv.readfromstream(_Reader, 1)[0];
this.Role = role == 0 ? delegates.Roles.Moderator : delegates.Roles.Viewer;
SessionInfoAvailable.Invoke(id, role == 0 ? delegates.Roles.Moderator : delegates.Roles.Viewer);
break;
case headers.infotype.EndSession:
stopAsyncRead();
SessionEnded.Invoke();
break;
case headers.infotype.ViewerJoined:
ViewerJoinedSession.Invoke();
break;
case headers.infotype.QuitSession:
ViewerQuitSession.Invoke();
break;
case headers.infotype.RequestModerator:
ModeratorRequest.Invoke();
break;
case headers.infotype.RequestDenied:
RequestAnswerAvailable.Invoke(false);
break;
case headers.infotype.RequestAccepted:
RequestAnswerAvailable.Invoke(true);
break;
}
}
public async Task CloseSessionAsync(bool expected)
{
try
{
if (Connected && State.Controlling)
{
var maxdl = Task.Delay(TLCFIDataProvider.Default.Settings.MaxReleaseControlDuration,
_sessionCancellationToken);
var relct = Task.Run(async() =>
{
while (State.Controlling)
{
await Task.Delay(100, _sessionCancellationToken);
}
}, _sessionCancellationToken);
await Task.WhenAny(maxdl, relct);
}
StopAliveTimers();
if (Connected && State.Registered)
{
try
{
await TLCProxy.DeregisterAsync(new DeregistrationRequest(),
_sessionCancellationToken);
_logger.Info("Deregistered succesfully from TLC.");
}
catch (Exception e)
{
_logger.Error(e, "Error while deregistering: ");
}
}
SessionEnded?.Invoke(this, expected);
}
catch (TaskCanceledException)
{
}
}
protected void OnSessionEnded(EventArgs e) => SessionEnded?.Invoke(this, e);
internal void OnSessionEnded() => SessionEnded?.Invoke(this, null);
protected virtual void OnSessionEnded()
{
SessionEnded?.Invoke(this, null);
}
void DebugEngine_SessionEnded(object sender, EventArgs args)
{
((IGgpDebugEngine)sender).SessionEnded -= DebugEngine_SessionEnded;
SessionEnded?.Invoke(this, args);
}
private void TerminateMeterSession()
{
IList <IService> services = ansiProtocolSession.Services;
try
{
#if DEBUG
ansiProtocolSession.RawDataSent -= Session_RawDataSent;
ansiProtocolSession.RawDataReceived -= Session_RawDataReceived;
#endif
ansiProtocolSession.SessionStarting -= Session_Starting;
ansiProtocolSession.SessionStartError -= Session_StartError;
ansiProtocolSession.SessionStarted -= Session_Started;
ansiProtocolSession.SessionTimeout -= Session_Timeout;
ansiProtocolSession.HandshakeInitializing -= Session_HandshakeInitializing;
ansiProtocolSession.HandshakeInitialized -= Session_HandshakeInitialized;
ansiProtocolSession.HandshakeError -= Session_HandshakeError;
ansiProtocolSession.HandshakeCompleted -= Session_HandshakeCompleted;
ansiProtocolSession.ServiceExecutionStarted -= Session_ServiceExecutionStarted;
ansiProtocolSession.ServiceExecutionCompleted -= Session_ServiceExecutionCompleted;
ansiProtocolSession.ServiceExecutionError -= Session_ServiceExecutionError;
ansiProtocolSession.ServiceExecutionCanceled -= Session_ServiceExecutionCanceled;
ansiProtocolSession.ServicesExecutionCompleted -= Session_ServicesExecutionCompleted;
ansiProtocolSession.SessionClosing -= Session_Closing;
ansiProtocolSession.SessionClosed -= Session_Closed;
ansiProtocolSession.Dispose();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"Dispose Session Error. {ex.Message}");
}
finally
{
ansiProtocolSession = null;
}
reconnectionAttempts++;
var taskCompletedCount = CurrentMeterSession.SessionTasks.Values.Count(x => x.Completed);
if ((taskCompletedCount > 0) ||
(CurrentMeterSession.SessionSetting.ReconnectionSchema == null) ||
(reconnectionAttempts > CurrentMeterSession.SessionSetting.ReconnectionSchema.MaxReconnectionAttempts))
{
reconnectionCountdownTimer?.Dispose();
CurrentMeterSession.EndDate = DateTime.UtcNow;
CurrentMeterSession.SessionTrace = sessionTracer.ToString();
int dataSetExecutionPercent = taskCompletedCount * 100 / CurrentMeterSession.SessionTasks.Count;
var dataSetExecutionQuality = (dataSetExecutionPercent == 0) ? DataSetExecutionQuality.Critical
: (dataSetExecutionPercent <= 25) ? DataSetExecutionQuality.VeryPoor
: (dataSetExecutionPercent <= 50) ? DataSetExecutionQuality.Poor
: (dataSetExecutionPercent <= 75) ? DataSetExecutionQuality.Moderate
: (dataSetExecutionPercent < 100) ? DataSetExecutionQuality.Good
: DataSetExecutionQuality.Great;
var sessionEndedEventArgs = new SessionEndedEventArgs()
{
MeterSession = CurrentMeterSession,
TotalBytesSent = totalBytesSent,
TotalBytesReceived = totalBytesReceived,
DataSetExecutionSuccess = taskCompletedCount == CurrentMeterSession.SessionTasks.Count,
DataSetExecutionPercent = dataSetExecutionPercent,
DataSetExecutionQuality = dataSetExecutionQuality
};
SessionEnded?.Invoke(this, sessionEndedEventArgs);
reconnectionAttempts = 0;
sessionTracer.Clear();
totalBytesSent = 0; totalBytesReceived = 0;
}
else
{
currentReconnectionCountdown = CurrentMeterSession.SessionSetting.ReconnectionSchema.ReconnectionSchedules[reconnectionAttempts - 1].Schedule;
reconnectionCountdownTimer.Change(1000, 1000); // disparamos cada 1 segundos hasta que se waitTimeSpan llegue a cero.
}
}
/// <summary>
/// Starts Processing Commands
/// </summary>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>A Task which performs the operation</returns>
public async override Task StartAsync(CancellationToken cancellationToken)
{
// Validate Port before starting
if (Port == 0)
{
throw new Exception("Invalid port number");
}
// Initializes Server
try
{
Server = new TcpListener(IPAddress.Any, Port);
Server.Start(10);
// Notify the listening started
ListeningStarted?.Invoke(this, new ListeningStartedEventArgs(Port));
while (cancellationToken.IsCancellationRequested == false)
{
// Keep listening for incoming connections
var client = await Server.AcceptTcpClientAsync().WithCancellation(cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
// Creates the Communication Session
var sessionID = this.BeginSession();
// Notify that a session is started
var sessionStartedEventArgs = new SessionStartedEventArgs(sessionID);
SessionStarted?.Invoke(this, sessionStartedEventArgs);
// Make sure session is not denied
if (sessionStartedEventArgs.Deny)
{
// Session is denied, unregister it
this.EndSession(sessionID);
}
else
{
// Session is allowed, continue with it
var networkCommunicationSession = new NetworkCommunicationSession(client, sessionID, ShowTimer, ShowPrompt);
networkCommunicationSession.RawCommandReceived += (sender, commandEventArgs) =>
{
// Executes the command and waits for the answer
var taskResponse = Task.Run <CommandExecutionResponse>(async() => await ExecuteCommandAsync(networkCommunicationSession.ID, commandEventArgs.RawCommand));
var response = taskResponse.Result;
// Outputs the response
commandEventArgs.Response = this.ResponseFormatter.Format(response);
// Replace "\n" by the environment NewLine
commandEventArgs.Response = commandEventArgs.Response.Replace("\n", System.Environment.NewLine);
};
// Add session to the collection
lock (NetworkCommunicationSessionsLock)
{
NetworkCommunicationSessions.Add(networkCommunicationSession.ID, networkCommunicationSession);
}
#pragma warning disable 4014
// Run Communication Session
networkCommunicationSession.RunAsync(cancellationToken).ContinueWith(t =>
{
// Stop Session
networkCommunicationSession.Stop();
// Remove Session from Internal Controls
lock (NetworkCommunicationSessionsLock)
{
NetworkCommunicationSessions.Remove(networkCommunicationSession.ID);
}
// Unregister session with the Command Processor
this.EndSession(networkCommunicationSession.ID);
// Call SessionEnded event
SessionEnded?.Invoke(this, new SessionEndedEventArgs(networkCommunicationSession.ID));
}, cancellationToken);
#pragma warning restore 4014
}
}
}
catch (Exception)
{
throw;
}
finally
{
if (Server != null)
{
Server.Stop();
}
}
}
private void Client_Disconnected(object sender, EventArgs e)
{
StopAliveTimers();
Disconnected?.Invoke(this, EventArgs.Empty);
SessionEnded?.Invoke(this, false);
}
