/// <summary>
/// Multiple threads are required in order to send and receive streamed data if the user interface is going to be responsive.
/// The best way I could seperate the visual content from the multiple threads required to send and receive streamed data was via the use
/// of delegates. I could have passed the classes in such as MainWindow or mP2P, however this would have greatly increased the dependencies.
/// By using delegates this class can stand on it's own without using MainWindow or mP2P.
/// </summary>
/// <param name="nodeName">This Node's name</param>
/// <param name="threadFinishedDelegate">The delegate to respond when the Thread has finished (this will only happen when it is canceled via </param>
public StreamingHttpListener(String uniqueStreamName, WorkerThreadFinished threadFinishedDelegate,
LogMessage msg, StartStream startStream, SendStream sendStream)
{
mLogMessage = msg;
mUniqueStreamName = uniqueStreamName;
mStartStream = startStream;
mSendStream = sendStream;
//start the audioHttpListenerThread. This thread contains the AudioHttpServer and responds to requests from
//the mAudioPlayer
mHttpListenerThread = new System.ComponentModel.BackgroundWorker();
mHttpListenerThread.DoWork += new System.ComponentModel.DoWorkEventHandler(PseudoHttpServer);
mHttpListenerThread.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(threadFinishedDelegate);
mHttpListenerThread.WorkerSupportsCancellation = true;
mHttpListenerThread.RunWorkerAsync(null);
//initialize the audio parameters.
mIncommingStream = false;
mSyncStreamLastWrittenPos = 0;
mPseudoStream = new MemoryStream();
mSyncStream = Stream.Synchronized(mPseudoStream);
mHashTable = new System.Collections.Hashtable();
mTimer = new Timer(new TimerCallback(TimerCallback));
mTimer.Change(0, 3500);//every 3500ms get a callback
}
public void Dispose()
{
RawReceiveStream?.Dispose();
SendStream?.Dispose();
ReceiveStream?.Dispose();
_webSocket?.Dispose();
}
HttpWebRequest buildRequest(string method, string name, CookieContainer cookies)
{
GXLogging.Debug(log, String.Format("Start HTTPClient buildRequest: requestUrl:{0} method:{1} name:{2}", _url, method, name));
int BytesRead;
Byte[] Buffer = new Byte[1024];
string requestUrl = GetRequestURL(name);
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(requestUrl);
if (GXUtil.CompressResponse())
{
req.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
}
req.Credentials = getCredentialCache(req.RequestUri, _authCollection);
req.CookieContainer = cookies;
foreach (X509Certificate2 cert in _certificateCollection)
{
req.ClientCertificates.Add(cert);
}
req.Method = method.Trim();
req.Timeout = _timeout;
setHttpVersion(req);
WebProxy proxy = getProxy(_proxyHost, _proxyPort, _authProxyCollection);
if (proxy != null)
{
req.Proxy = proxy;
}
setHeaders(req);
if (method.ToUpper() != "GET")
{
#if !NETCORE
using (Stream reqStream = req.GetRequestStream())
#else
using (Stream reqStream = req.GetRequestStreamAsync().GetAwaiter().GetResult())
#endif
{
sendVariables(reqStream);
SendStream.Seek(0, SeekOrigin.Begin);
BytesRead = SendStream.Read(Buffer, 0, 1024);
GXLogging.Debug(log, "Start SendStream.Read: BytesRead " + BytesRead);
while (BytesRead > 0)
{
GXLogging.Debug(log, "reqStream.Write: Buffer.length " + Buffer.Length + ",'" + Encoding.UTF8.GetString(Buffer, 0, Buffer.Length) + "'");
reqStream.Write(Buffer, 0, BytesRead);
BytesRead = SendStream.Read(Buffer, 0, 1024);
}
EndMultipartBoundary(reqStream);
}
}
return(req);
}
public void Dispose()
{
SendStream?.Dispose();
SendStream = null;
ReceiveStream?.Dispose();
ReceiveStream = null;
_socket?.Dispose();
_socket = null;
}
/// <summary>
/// Send an entire stream
/// </summary>
/// <param name="msg">Message</param>
public void SendStream(SendStream msg)
{
if (_stream.CanRead)
{
#if NET_3_5
CopyTo(msg.Stream, _stream);
#else
msg.Stream.CopyTo(_stream);
#endif
}
msg.Stream.Dispose();
}
private void StartMultipartFile(string name, string s)
{
if (IsMultipart && File.Exists(s))
{
s = Path.GetFileName(s);
if (string.IsNullOrEmpty(name))
{
name = Path.GetFileNameWithoutExtension(s);
}
SendStream.Write(MultiPart.Boundarybytes, 0, MultiPart.Boundarybytes.Length);
var header = string.Format(MultiPart.HeaderTemplate, name, s, MimeMapping.GetMimeMapping(s));
var headerbytes = Encoding.UTF8.GetBytes(header);
SendStream.Write(headerbytes, 0, headerbytes.Length);
}
}
public void AddFile(string s, string name)
{
StartMultipartFile(name, s);
#pragma warning disable SCS0018 // Path traversal: injection possible in {1} argument passed to '{0}'
using (FileStream fs = new FileStream(s, FileMode.Open, FileAccess.Read))
#pragma warning restore SCS0018 // Path traversal: injection possible in {1} argument passed to '{0}'
{
byte[] buffer = new Byte[1024];
int bytesRead = fs.Read(buffer, 0, 1024);
while (bytesRead > 0)
{
SendStream.Write(buffer, 0, bytesRead);
bytesRead = fs.Read(buffer, 0, 1024);
}
}
}
public void Dispose()
{
try
{
SendStream?.Dispose();
}
catch (ObjectDisposedException)
{
}
catch (NullReferenceException)
{
}
finally
{
SendStream = null;
}
try
{
ReceiveStream?.Dispose();
}
catch (ObjectDisposedException)
{
}
catch (NullReferenceException)
{
}
finally
{
ReceiveStream = null;
}
try
{
_socket?.Dispose();
}
catch (ObjectDisposedException)
{
}
catch (NullReferenceException)
{
}
finally
{
_socket = null;
}
}
public override void SendUpdate()
{
ProfilerShort.Begin("ClientState.WriteAcks");
// Client ACK Packet - reliable
SendStream.ResetWrite();
// ACK Header
// Write last state sync packet id
SendStream.WriteByte(m_lastStateSyncPacketId);
// Write ACKs
byte num = (byte)m_acks.Count;
SendStream.WriteByte(num);
for (int i = 0; i < num; i++)
{
SendStream.WriteByte(m_acks[i]);
}
SendStream.Terminate();
m_acks.Clear();
ProfilerShort.End();
m_callback.SendClientAcks(SendStream);
// Client Update Packet
SendStream.ResetWrite();
m_clientPacketId++;
SendStream.WriteByte(m_clientPacketId);
SendStream.WriteDouble(MyTimeSpan.FromTicks(Stopwatch.GetTimestamp()).Milliseconds);
ProfilerShort.Begin("ClientState.Serialize");
if (VRage.MyCompilationSymbols.EnableNetworkPacketTracking)
{
Trace.MyTrace.Send(Trace.TraceWindow.MPackets, "Send client update: ");
}
// Write Client state
ClientState.Serialize(SendStream, false);
ProfilerShort.End();
SendStream.Terminate();
ProfilerShort.Begin("SendClientUpdate");
m_callback.SendClientUpdate(SendStream);
ProfilerShort.End();
//Client.SendMessageToServer(m_sendStream, PacketReliabilityEnum.UNRELIABLE, PacketPriorityEnum.IMMEDIATE_PRIORITY, MyChannelEnum.StateDataSync);
}
/// <summary>
/// Send an entire stream
/// </summary>
/// <param name="msg">Message</param>
public void SendStream(SendStream msg)
{
msg.Stream.CopyTo(_stream);
msg.Stream.Dispose();
}
public void SendClientConnected(ref ConnectedClientDataMsg msg)
{
SendStream.ResetWrite();
VRage.Serialization.MySerializer.Write <ConnectedClientDataMsg>(SendStream, ref msg);
m_callback.SendConnectRequest(SendStream);
}
void SetReplicableReady(NetworkId networkId, IMyReplicable replicable, bool loaded)
{
try
{
MyPendingReplicable pendingReplicable;
if (m_pendingReplicables.TryGetValue(networkId, out pendingReplicable))
{
m_pendingReplicables.Remove(networkId);
if (loaded)
{
var ids = pendingReplicable.StateGroupIds;
AddNetworkObjectClient(networkId, replicable);
using (m_tmpGroups)
{
IMyStreamableReplicable streamable = replicable as IMyStreamableReplicable;
if (streamable != null && pendingReplicable.IsStreaming)
{
var group = streamable.GetStreamingStateGroup();
m_tmpGroups.Add(group);
}
replicable.GetStateGroups(m_tmpGroups);
Debug.Assert(ids.Count == m_tmpGroups.Count,
"Number of state groups on client and server for replicable does not match");
for (int i = 0; i < m_tmpGroups.Count; i++)
{
if (m_tmpGroups[i] != replicable && m_tmpGroups[i].GroupType != StateGroupEnum.Streaming)
{
AddNetworkObjectClient(ids[i], m_tmpGroups[i]);
}
}
}
m_eventBuffer.ProcessEvents(networkId, m_eventHandler, m_isBlockedHandler, NetworkId.Invalid);
}
else
{
MyLog.Default.WriteLine("Failed to create replicable ! Type : " + replicable.ToString());
m_eventBuffer.RemoveEvents(networkId);
IMyStreamableReplicable streamable = replicable as IMyStreamableReplicable;
if (streamable != null && pendingReplicable.IsStreaming)
{
var group = streamable.GetStreamingStateGroup();
group.Destroy();
NetworkId streaingGroupId;
if (TryGetNetworkIdByObject(group, out streaingGroupId))
{
RemoveNetworkedObject(group);
}
MyLog.Default.WriteLine("removing streaming group for not loaded replicable !");
}
}
SendStream.ResetWrite();
SendStream.WriteNetworkId(networkId);
SendStream.WriteBool(loaded);
SendStream.Terminate();
m_callback.SendReplicableReady(SendStream);
}
else
{
m_pendingReplicables.Remove(networkId);
using (m_tmpGroups)
{
IMyStreamableReplicable streamable = replicable as IMyStreamableReplicable;
if (streamable != null && streamable.NeedsToBeStreamed)
{
var group = streamable.GetStreamingStateGroup();
m_tmpGroups.Add(group);
MyLog.Default.WriteLine("removing streaming group for not loaded replicable !");
}
replicable.GetStateGroups(m_tmpGroups);
foreach (var g in m_tmpGroups)
{
if (g != null)
// when terminal repblicable fails to attach to block its state group is null becouase its created inside hook method.
{
g.Destroy();
}
}
}
replicable.OnDestroy();
}
}
catch (Exception ex)
{
MyLog.Default.WriteLine(ex);
throw;
//m_callback.DisconnectFromHost();
}
}
public void Dispose()
{
var oneStreamIsUsed = SendStream != null && ReceiveStream != null && ReferenceEquals(SendStream, ReceiveStream);
try
{
SendStream?.Dispose();
}
catch (ObjectDisposedException)
{
}
catch (NullReferenceException)
{
}
finally
{
SendStream = null;
}
try
{
if (!oneStreamIsUsed)
{
ReceiveStream?.Dispose();
}
}
catch (ObjectDisposedException)
{
}
catch (NullReferenceException)
{
}
finally
{
ReceiveStream = null;
}
try
{
_sslStream?.Dispose();
}
catch (ObjectDisposedException)
{
}
catch (NullReferenceException)
{
}
finally
{
_sslStream = null;
}
try
{
_socket?.Dispose();
}
catch (ObjectDisposedException)
{
}
catch (NullReferenceException)
{
}
finally
{
_socket = null;
}
}
