protected virtual void OnClosedEvent(StreamEventArgs args)
{
if (ClosedEvent != null)
{
ClosedEvent(this, args);
}
}
/// <summary>
/// Event handler for SM protocol data.
/// </summary>
/// <param name="sender">the sender object.</param>
/// <param name="e">Event arguments.</param>
private void OnProtocolData(object sender, StreamEventArgs e)
{
if (e.Stream == this)
{
if (SMStreamState.Closed == e.Stream.State)
{
this.Close(StatusCode.ProtocolError);
return;
}
if (e is HeadersEventArgs)
{
var args = (HeadersEventArgs)e;
this.Headers.Merge(args.Headers);
if (this.OnHeadersReceived != null)
{
this.OnHeadersReceived(this, args);
}
}
else if (e is StreamDataEventArgs)
{
StreamDataEventArgs arg = e as StreamDataEventArgs;
if (arg.IsFin && this.State == SMStreamState.HalfClosed)
{
this.Close();
}
if (this.OnDataReceived != null)
{
StreamDataEventArgs args = (StreamDataEventArgs)e;
this.OnDataReceived(this, e as StreamDataEventArgs);
if (Session.IsFlowControlEnabled)
{
Session.CurrentCreditBalanceFromServer -= args.Data.Data.Length;
if (Session.CurrentCreditBalanceFromServer + Session.CreditAddition < Session.MaxCreditBalance)
{
if (Session.CurrentCreditBalanceFromServer < 0)
{
SendCreditUpdate(Convert.ToInt32((-1 * Session.CurrentCreditBalanceFromServer / Session.CreditAddition +
1) * Session.CreditAddition));
}
else
{
SendCreditUpdate(Convert.ToInt32(Session.CreditAddition));
}
}
}
}
}
else if (e is RSTEventArgs)
{
if (this.OnRSTReceived != null)
{
this.OnRSTReceived(this, e as RSTEventArgs);
}
}
}
}
public void ReceivingUnknownDataRaisesEvent()
{
// Arrange
string strContent = "{\"test\":[1,2,3]}";
var execute = new Mock <ITwitterExecute>();
StreamContent content = new StreamContent(execute.Object, strContent);
var stream = new Mock <IStreamingConnection>();
stream.Setup(s => s.Start(It.IsAny <Func <IStreamContent, Task> >()))
.Callback <Func <StreamContent, Task> >(func => func(content))
.Returns(Task.FromResult(new List <IStreaming>()));
var parser = StreamParser.Create(stream.Object);
StreamEventArgs receivedData = null;
ManualResetEventSlim waitHandle = new ManualResetEventSlim(false);
parser.UnknownDataReceived += (s, e) =>
{
receivedData = e;
waitHandle.Set();
};
// Act
parser.StartStreaming();
waitHandle.Wait(1000);
// Assert
Assert.IsNotNull(receivedData);
Assert.AreEqual(strContent, receivedData.Json);
}
private void session_OnStreamOpened(object sender, StreamEventArgs e)
{
string file = e.Stream.Headers[ProtocolHeaders.Path];
Console.WriteLine("Requested file: " + file);
if (string.IsNullOrEmpty(file))
{
Console.WriteLine("Empty file name in the request");
e.Stream.Close(StatusCode.RefusedStream);
return;
}
string path = Path.GetFullPath("root" + file);
if (!File.Exists(path))
{
Console.WriteLine("File {0} not found", file);
e.Stream.Close(StatusCode.RefusedStream);
return;
}
try
{
using (StreamReader sr = new StreamReader(path))
{
e.Stream.SendData(new ProtocolData(sr.ReadToEnd()), true);
Console.WriteLine("File {0} sent", file);
}
}
finally
{
e.Stream.Close();
}
}
protected virtual void OnHasBytesAvailableEvent(StreamEventArgs args)
{
if (HasBytesAvailableEvent != null)
{
HasBytesAvailableEvent(this, args);
}
}
protected virtual void OnCallback(CFStreamEventType type)
{
var args = new StreamEventArgs(type);
switch (type)
{
case CFStreamEventType.OpenCompleted:
OnOpenCompleted(args);
break;
case CFStreamEventType.CanAcceptBytes:
OnCanAcceptBytesEvent(args);
break;
case CFStreamEventType.HasBytesAvailable:
OnHasBytesAvailableEvent(args);
break;
case CFStreamEventType.ErrorOccurred:
OnErrorEvent(args);
break;
case CFStreamEventType.EndEncountered:
OnClosedEvent(args);
break;
}
}
protected virtual void OnCanAcceptBytesEvent(StreamEventArgs args)
{
if (CanAcceptBytesEvent != null)
{
CanAcceptBytesEvent(this, args);
}
}
private void StreamingCallback(object sender, StreamEventArgs e)
{
var json = Twitch.Utility.DynamicJson.Parse(e.Data);
Twitter.Status status;
try
{
status = new Twitter.Status(json.ToString());
}
catch
{
if (!this.IsTolerance)
throw new ApplicationException(
"不明なメッセージが発行されました。\"" + json.ToString() + "\"" + Environment.NewLine +
"この種の予期しないメッセージに対して例外を発生させない場合は、このStreamの IsTolerance プロパティを true に設定してください。");
return;
}
this.OnStatusUpdated(
new StatusUpdatedEventArgs
{
Status = status
}
);
}
protected virtual void OnErrorEvent(StreamEventArgs args)
{
if (ErrorEvent != null)
{
ErrorEvent(this, args);
}
}
private void StreamingCallback(object sender, StreamEventArgs e)
{
var json = Twitch.Utility.DynamicJson.Parse(e.Data);
Entity.Status status;
try
{
status = new Entity.Status(json.ToString());
}
catch
{
if (!this.IsTolerance)
{
throw new ApplicationException(
"不明なメッセージが発行されました。\"" + json.ToString() + "\"" + Environment.NewLine +
"この種の予期しないメッセージに対して例外を発生させない場合は、このStreamの IsTolerance プロパティを true に設定してください。");
}
return;
}
this.OnStatusUpdated(
new StatusUpdatedEventArgs
{
Status = status
}
);
}
public virtual void OnStreamEvent(StreamEventArgs e)
{
if (StreamEvent != null)
{
StreamEvent(this, e);
}
}
/// <summary>
/// Raises the <see cref="E:StreamChanged" /> event.
/// </summary>
/// <param name="e">The <see cref="StreamEventArgs"/> instance containing the event data.</param>
internal void OnStreamChanged(StreamEventArgs e)
{
if (streamChangedHandlers != null)
{
streamChangedHandlers(client, e);
}
}
protected virtual void OnOpenCompleted(StreamEventArgs args)
{
if (OpenCompletedEvent != null)
{
OpenCompletedEvent(this, args);
}
}
private void GtpFixtureStreamEvent(object sender, StreamEventArgs e)
{
try
{
//Notice the two-step deserialization
var streamMessage = e.Update.FromJson <StreamMessage>();
var fixtureDelta = streamMessage.GetContent <Fixture>();
_logger.InfoFormat("Streaming Update arrived for {0} id {1} sequence {2}", _gtpFixture.Name, _gtpFixture.Id, fixtureDelta.Sequence);
if (fixtureDelta.Sequence < _currentSequence)
{
_logger.InfoFormat("Fixture {0} id {1} sequence {2} is less than current sequence {3}", _gtpFixture.Name, _gtpFixture.Id, fixtureDelta.Sequence, _currentSequence);
return;
}
if ((fixtureDelta.Sequence - _currentSequence) > 1)
{
_logger.WarnFormat("Fixture {0} id {1} sequence {2} is more than one greater that current sequence {3}", _gtpFixture.Name, _gtpFixture.Id, fixtureDelta.Sequence, _currentSequence);
}
_currentSequence = fixtureDelta.Sequence;
//If the stream epoch does not equal the current epoch,
//then we need to pause streaming, process the snapshot, carry on streaming
if (fixtureDelta.Epoch > _currentEpoch)
{
_logger.InfoFormat("Epoch changed for {0} from {1} to {2}", _gtpFixture.Name, _currentEpoch, fixtureDelta.Epoch);
_currentEpoch = fixtureDelta.Epoch;
if (fixtureDelta.LastEpochChangeReason != null && fixtureDelta.LastEpochChangeReason.Contains((int)SSEpochChangeReason.StartTime))
{
_logger.InfoFormat("Fixture {0} has had its start time changed", _gtpFixture.Name);
ProcessDelta(fixtureDelta);
}
if (fixtureDelta.LastEpochChangeReason != null && fixtureDelta.LastEpochChangeReason.Contains((int)SSEpochChangeReason.Deleted))
{
_logger.InfoFormat("Fixture {0} has been deleted from the GTP Fixture Factroy. Suspending all markets and stopping the stream", _gtpFixture.Name);
_gtpFixture.StopStreaming();
SuspendAllMarkets();
FixtureEnded = true;
}
else
{
SuspendAndReprocessSnapshot();
}
}
else if (fixtureDelta.Epoch == _currentEpoch)
{
ProcessDelta(fixtureDelta);
}
}
catch (Exception ex)
{
_logger.Error(ex);
}
}
protected virtual void OnCanAcceptBytesEvent(StreamEventArgs args)
{
var e = CanAcceptBytesEvent;
if (e != null)
{
e(this, args);
}
}
protected virtual void OnErrorEvent(StreamEventArgs args)
{
var e = ErrorEvent;
if (e != null)
{
e(this, args);
}
}
protected virtual void OnClosedEvent(StreamEventArgs args)
{
var e = ClosedEvent;
if (e != null)
{
e(this, args);
}
}
protected virtual void OnOpenCompleted(StreamEventArgs args)
{
var e = OpenCompletedEvent;
if (e != null)
{
e(this, args);
}
}
internal void DoAfterDecompress(StreamEventArgs e)
{
var handler = AfterDecompress;
if (handler != null)
{
handler(this, e);
}
}
protected virtual void OnHasBytesAvailableEvent(StreamEventArgs args)
{
var e = HasBytesAvailableEvent;
if (e != null)
{
e(this, args);
}
}
public virtual async Task OnStreamEvent(StreamEventArgs e)
{
Logger.LogDebug("Resource \"{0}\" OnStreamEvent()", Id);
if (StreamEvent != null)
{
await StreamEvent(this, e);
}
}
internal void DoBeforeCompress(StreamEventArgs e)
{
var handler = BeforeCompress;
if (handler != null)
{
handler(this, e);
}
}
/// <summary>
/// Event handler for protocol data.
/// </summary>
/// <param name="sender">the sender object.</param>
/// <param name="e">Event arguments.</param>
private void OnProtocolData(object sender, StreamEventArgs e)
{
if (e.Stream == this)
{
if (Http2StreamState.Closed == e.Stream.State)
{
this.Close(StatusCode.ProtocolError);
return;
}
if (e is HeadersEventArgs)
{
var args = (HeadersEventArgs)e;
this.Headers.Merge(args.Headers);
if (this.OnHeadersReceived != null)
{
this.OnHeadersReceived(this, args);
}
}
else if (e is StreamDataEventArgs)
{
StreamDataEventArgs arg = e as StreamDataEventArgs;
if (arg.IsFin && this.State == Http2StreamState.HalfClosed)
{
this.Close();
}
if (this.OnDataReceived != null)
{
StreamDataEventArgs args = (StreamDataEventArgs)e;
this.OnDataReceived(this, e as StreamDataEventArgs);
//TODO incomment when server will be able to handle windowUpdate
/*if (Session.IsFlowControlEnabled)
* {
* CurrentWindowBalanceFromServer -= args.Data.Data.Length;
* if (CurrentWindowBalanceFromServer <= 0)
* this.protocol.SendWindowUpdate(this, Session.CurrentWindowBalanceToServer);
* }*/
}
}
else if (e is RSTEventArgs)
{
if (this.OnRSTReceived != null)
{
this.OnRSTReceived(this, e as RSTEventArgs);
}
}
}
}
/// <summary>
/// Event handler called every time the <see cref="EventRaisingStreamWriter"/> writes in the <see cref="MemoryStream"/>.
/// This event handler is called each time the Python script uses the output.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The arguments.</param>
public void OnMemoryStreamChanged(object sender, StreamEventArgs <string> e)
{
try
{
// Check if the script should be stopped
if (this.CancellationToken.IsCancellationRequested)
{
this.Engine.Runtime.Shutdown();
throw new OperationCanceledException(this.CancellationToken);
}
// Update the content of the output
Application.Current.Dispatcher.Invoke(
DispatcherPriority.Input,
new Action(() => this.OutputTerminal.AppendText(e.Value)));
}
catch (ThreadAbortException tae)
{
// If a ThreadAbortException occured but the user didn't choose to stop the script
if (!(tae.ExceptionState is KeyboardInterruptException))
{
Application.Current.Dispatcher.Invoke(
DispatcherPriority.Input,
new Action(() => this.OutputTerminal.AppendText(string.Format("\nAn error occured during the execution of the script !\nError: {0}\n", tae.Message))));
}
// The abortion of the thread is cancelled to avoid the loss of data, the cancelletation token is checked and will throw an exception to cancel the task properly if necessary
Thread.ResetAbort();
this.Engine.Runtime.Shutdown();
this.CancellationToken.ThrowIfCancellationRequested();
}
// If CancellationRequested
catch (OperationCanceledException)
{
throw new OperationCanceledException(this.CancellationToken);
}
// Other kinds of exceptions
catch (Exception ex)
{
Application.Current.Dispatcher.Invoke(
DispatcherPriority.Input,
new Action(() => this.OutputTerminal.AppendText(string.Format("\nAn error occured during the execution of the script !\nError: {0}\n", ex.Message))));
}
}
/// <summary>
/// Called when a stream changes within the tor service.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="StreamEventArgs"/> instance containing the event data.</param>
private void OnStreamChanged(object sender, StreamEventArgs e)
{
if (e.Stream == null)
{
return;
}
lock (synchronizeStreams)
{
Stream existing = streams.Where(s => s.ID == e.Stream.ID).FirstOrDefault();
if (existing == null)
{
if (Status.MaximumRecords <= streams.Count)
{
Stream removal = streams.Where(s => s.Status == StreamStatus.Closed || s.Status == StreamStatus.Failed).FirstOrDefault();
if (removal == null)
{
return;
}
streams.Remove(removal);
}
existing = e.Stream;
streams.Add(existing);
}
else
{
existing.CircuitID = e.Stream.CircuitID;
existing.Purpose = e.Stream.Purpose;
existing.Reason = e.Stream.Reason;
existing.Status = e.Stream.Status;
}
}
if (StreamsChanged != null)
{
StreamsChanged(client, EventArgs.Empty);
}
}
public void ReceivingUnknownDataRaisesEvent()
{
// Arrange
const string strContent = "{\"test\":[1,2,3]}";
ManualResetEventSlim waitHandle = new ManualResetEventSlim(false);
var parser = SetupParser(strContent);
StreamEventArgs receivedData = null;
parser.UnknownDataReceived += (s, e) =>
{
receivedData = e;
waitHandle.Set();
};
// Act
parser.StartStreaming();
waitHandle.Wait(1000);
// Assert
Assert.IsNotNull(receivedData);
Assert.AreEqual(strContent, receivedData.Json);
}
#pragma warning disable IDE0060 // Remove unused parameter
public static void StreamEventProcessor(object?sender, StreamEventArgs args)
#pragma warning restore IDE0060 // Remove unused parameter
{
switch (args.Type)
{
case StreamEventType.OnHeaderProcessing:
ParseDlnaHeaders(args.Request !, args.StreamingRequest !);
break;
case StreamEventType.OnStreamStart:
AddDlnaHeaders(args.State !, args.ResponseHeaders !, ProfileManager !, args.IsStaticallyStreamed, args.StartTimeTicks, args.Request !);
break;
default:
ApplyDeviceProfileSettings(
args.State !,
args.DeviceManager !,
ProfileManager !,
args.Request !,
args.DeviceProfileId,
args.IsStaticallyStreamed);
break;
}
}
protected virtual void OnErrorEvent(StreamEventArgs args)
{
if (ErrorEvent != null)
ErrorEvent (this, args);
}
protected virtual void OnHasBytesAvailableEvent(StreamEventArgs args)
{
if (HasBytesAvailableEvent != null)
HasBytesAvailableEvent (this, args);
}
protected virtual void OnCanAcceptBytesEvent(StreamEventArgs args)
{
if (CanAcceptBytesEvent != null)
CanAcceptBytesEvent (this, args);
}
protected virtual void OnClosedEvent(StreamEventArgs args)
{
if (ClosedEvent != null)
ClosedEvent (this, args);
}
/// <summary>
/// Event handler for protocol data.
/// </summary>
/// <param name="sender">the sender object.</param>
/// <param name="e">Event arguments.</param>
private void OnProtocolData(object sender, StreamEventArgs e)
{
if (e.Stream == this)
{
if (Http2StreamState.Closed == e.Stream.State)
{
this.Close(StatusCode.ProtocolError);
return;
}
if (e is HeadersEventArgs)
{
var args = (HeadersEventArgs)e;
this.Headers.Merge(args.Headers);
if (this.OnHeadersReceived != null)
{
this.OnHeadersReceived(this, args);
}
}
else if (e is StreamDataEventArgs)
{
StreamDataEventArgs arg = e as StreamDataEventArgs;
if (arg.IsFin && this.State == Http2StreamState.HalfClosed)
{
this.Close();
}
if (this.OnDataReceived != null)
{
StreamDataEventArgs args = (StreamDataEventArgs)e;
this.OnDataReceived(this, e as StreamDataEventArgs);
//TODO incomment when server will be able to handle windowUpdate
/*if (Session.IsFlowControlEnabled)
{
CurrentWindowBalanceFromServer -= args.Data.Data.Length;
if (CurrentWindowBalanceFromServer <= 0)
this.protocol.SendWindowUpdate(this, Session.CurrentWindowBalanceToServer);
}*/
}
}
else if (e is RSTEventArgs)
{
if (this.OnRSTReceived != null)
{
this.OnRSTReceived(this, e as RSTEventArgs);
}
}
}
}
/// <summary>
/// Event handler for SM protocol data.
/// </summary>
/// <param name="sender">the sender object.</param>
/// <param name="e">Event arguments.</param>
private void OnProtocolData(object sender, StreamEventArgs e)
{
if (e.Stream == this)
{
if (SMStreamState.Closed == e.Stream.State)
{
this.Close(StatusCode.ProtocolError);
return;
}
if (e is HeadersEventArgs)
{
var args = (HeadersEventArgs)e;
this.Headers.Merge(args.Headers);
if (this.OnHeadersReceived != null)
{
this.OnHeadersReceived(this, args);
}
}
else if (e is StreamDataEventArgs)
{
StreamDataEventArgs arg = e as StreamDataEventArgs;
if (arg.IsFin && this.State == SMStreamState.HalfClosed)
{
this.Close();
}
if (this.OnDataReceived != null)
{
StreamDataEventArgs args = (StreamDataEventArgs)e;
this.OnDataReceived(this, e as StreamDataEventArgs);
if (Session.IsFlowControlEnabled)
{
Session.CurrentCreditBalanceFromServer -= args.Data.Data.Length;
if (Session.CurrentCreditBalanceFromServer + Session.CreditAddition < Session.MaxCreditBalance)
{
if (Session.CurrentCreditBalanceFromServer < 0)
SendCreditUpdate(Convert.ToInt32((-1*Session.CurrentCreditBalanceFromServer/Session.CreditAddition +
1)*Session.CreditAddition));
else
SendCreditUpdate(Convert.ToInt32(Session.CreditAddition));
}
}
}
}
else if (e is RSTEventArgs)
{
if (this.OnRSTReceived != null)
{
this.OnRSTReceived(this, e as RSTEventArgs);
}
}
}
}
private void EnqueueDebugSender(object sender, StreamEventArgs args)
{
DebugMessages.Enqueue(args.Message);
}
private void AddNewlyStartedStreams(TwitchRootObject obj)
{
if (obj == null || obj.Streams == null || obj.Streams.Count == 0)
return;
foreach(var stream in obj.Streams)
{
bool globalancounce = false;
if(_streamData.Keys.Contains(stream.Channel.Name))
{
globalancounce = true;
}
bool bTryAddresult = _streamData.TryAdd(stream.Channel.Name, new TwitchStreamData { Started = DateTime.Now, Stream = stream });
if(bTryAddresult)
{
// Probably helps differentiate between different Game Titles from Response
string oldgame = xmlprovider.StreamInfo(stream.Channel.Name, "game");
string _game = "";
if (oldgame != stream.Channel.Game)
{
_game = stream.Channel.Game;
}
if (oldgame != stream.Game)
{
_game = stream.Game;
}
var _stream = new DeathmicChatbot.StreamInfo.Stream
{
Channel = stream.Channel.Name,
Game = _game,
Message = stream.Channel.Status
};
var _streamdata = new StreamData
{
Stream = _stream,
Started = DateTime.Now,
StreamProvider = this
};
TwitchStreamData _tstreamdata = new TwitchStreamData();
_tstreamdata.Started = DateTime.Now;
_tstreamdata.Stream = new DeathmicChatbot.StreamInfo.Twitch.Stream();
_tstreamdata.Stream.Channel = new DeathmicChatbot.StreamInfo.Twitch.Channel();
_tstreamdata.Stream.Channel.Name = stream.Channel.Name;
_tstreamdata.Stream.Channel.Mature = stream.Channel.Mature;
_tstreamdata.Stream.Channel.ID = stream.Channel.ID;
_tstreamdata.Stream.Channel.Delay = stream.Channel.Delay;
_tstreamdata.Stream.Channel.Created_At = stream.Channel.Created_At;
_tstreamdata.Stream.Channel.Display_Name = stream.Channel.Display_Name;
_tstreamdata.Stream.Channel.Links = stream.Channel.Links;
_tstreamdata.Stream.Channel.Profile_Banner = stream.Channel.Profile_Banner;
_tstreamdata.Stream.Channel.Url = stream.Channel.Url;
_tstreamdata.Stream.Channel.Updated_At = stream.Channel.Updated_At;
_tstreamdata.Stream.Game = _game;
_tstreamdata.Stream.Channel.Game = _game;
AddStreamdatatoXML(_tstreamdata);
StreamEventArgs streamEventArgs = new StreamEventArgs(_streamdata);
StreamStarted(this, streamEventArgs);
}
if(!bTryAddresult && globalancounce)
{
string oldgame = xmlprovider.StreamInfo(stream.Channel.Name, "game");
string _game = "";
if (oldgame != stream.Channel.Game)
{
_game = stream.Channel.Game;
}
if (oldgame != stream.Game)
{
_game = stream.Game;
}
var _stream = new DeathmicChatbot.StreamInfo.Stream
{
Channel = stream.Channel.Name,
Game = _game,
Message = stream.Channel.Status
};
var _streamdata = new StreamData
{
Stream = _stream,
Started = DateTime.Now,
StreamProvider = this
};
StreamEventArgs streamEventArgs = new StreamEventArgs(_streamdata);
StreamGlobalNotification(this, streamEventArgs);
}
}
}
protected virtual void OnClosedEvent(StreamEventArgs args)
{
var e = ClosedEvent;
if (e != null)
e (this, args);
}
private void WriteWarningSender(object sender, StreamEventArgs args)
{
WriteWarningWithTimestamp(args.Message);
}
protected virtual void OnErrorEvent(StreamEventArgs args)
{
var e = ErrorEvent;
if (e != null)
e (this, args);
}
protected virtual void OnHasBytesAvailableEvent(StreamEventArgs args)
{
var e = HasBytesAvailableEvent;
if (e != null)
e (this, args);
}
protected virtual void OnOpenCompleted(StreamEventArgs args)
{
var e = OpenCompletedEvent;
if (e != null)
e (this, args);
}
protected virtual void OnOpenCompleted(StreamEventArgs args)
{
if (OpenCompletedEvent != null)
OpenCompletedEvent (this, args);
}
protected virtual void OnCanAcceptBytesEvent(StreamEventArgs args)
{
var e = CanAcceptBytesEvent;
if (e != null)
e (this, args);
}
private void RemoveStoppedStreams(TwitchRootObject obj)
{
foreach (var pair in from pair in _streamData where StreamStopped != null select pair)
{
bool bFound = obj.Streams.Any(stream => pair.Key == stream.Channel.Name);
if(!bFound)
{
TwitchStreamData sd;
_streamStopCounter.StreamTriesToStop(pair.Key);
if(_streamStopCounter.StreamHasTriedStoppingEnoughTimes(pair.Key) || !_streamData.TryRemove(pair.Key,out sd))
{
continue;
}
_streamStopCounter.StreamHasStopped(pair.Key);
var stream = new DeathmicChatbot.StreamInfo.Stream
{
Channel = pair.Value.Stream.Channel.Name,
Game = pair.Value.Stream.Game,
Message = pair.Value.Stream.Channel.Status
};
var streamData = new StreamData
{
Started = DateTime.Now,
Stream = stream,
StreamProvider = this
};
var streamEventArgs = new StreamEventArgs(streamData);
StreamStopped(this, streamEventArgs);
}
}
}
private void HandleStreamFinished(object sender, StreamEventArgs e)
{
//Dispose objects, close sessions if needed.
}
/// <summary>
/// Event handler for SM protocol data.
/// </summary>
/// <param name="sender">the sender object.</param>
/// <param name="e">Event arguments.</param>
private void OnProtocolData(object sender, StreamEventArgs e)
{
if (e.Stream == this)
{
if (SMStreamState.Closed == e.Stream.State)
{
this.Close(StatusCode.ProtocolError);
return;
}
if (e is HeadersEventArgs)
{
var args = (HeadersEventArgs)e;
this.Headers.Merge(args.Headers);
if (this.OnHeadersReceived != null)
{
this.OnHeadersReceived(this, args);
}
}
else if (e is StreamDataEventArgs)
{
StreamDataEventArgs arg = e as StreamDataEventArgs;
if (arg.IsFin && this.State == SMStreamState.HalfClosed)
{
this.Close();
}
if (this.OnDataReceived != null)
{
this.OnDataReceived(this, e as StreamDataEventArgs);
}
}
else if (e is RSTEventArgs)
{
if (this.OnRSTReceived != null)
{
this.OnRSTReceived(this, e as RSTEventArgs);
}
}
}
}
protected virtual void OnCallback(CFStreamEventType type)
{
var args = new StreamEventArgs (type);
switch (type) {
case CFStreamEventType.OpenCompleted:
OnOpenCompleted (args);
break;
case CFStreamEventType.CanAcceptBytes:
OnCanAcceptBytesEvent (args);
break;
case CFStreamEventType.HasBytesAvailable:
OnHasBytesAvailableEvent (args);
break;
case CFStreamEventType.ErrorOccurred:
OnErrorEvent (args);
break;
case CFStreamEventType.EndEncountered:
OnClosedEvent (args);
break;
}
}
private void WriteWarningSender(object sender, StreamEventArgs args)
{
_tasks.Enqueue(new Task(() => this.WriteWarning(args.Message)));
}
/// <summary>
/// Download complete
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void downloadComplete(object sender, Stream e)
{
if (DownloadComplete != null)
{
StreamEventArgs args = new StreamEventArgs();
args.Stream = e;
DownloadComplete.Invoke(this, args);
}
}
