public SecurityVerifiedMessage(Message messageToProcess, ReceiveSecurityHeader securityHeader)
: base(messageToProcess)
{
this.securityHeader = securityHeader;
if (securityHeader.RequireMessageProtection)
{
XmlDictionaryReader messageReader;
BufferedMessage bufferedMessage = this.InnerMessage as BufferedMessage;
if (bufferedMessage != null && this.Headers.ContainsOnlyBufferedMessageHeaders)
{
messageReader = bufferedMessage.GetMessageReader();
}
else
{
this.messageBuffer = new XmlBuffer(int.MaxValue);
XmlDictionaryWriter writer = this.messageBuffer.OpenSection(this.securityHeader.ReaderQuotas);
this.InnerMessage.WriteMessage(writer);
this.messageBuffer.CloseSection();
this.messageBuffer.Close();
messageReader = this.messageBuffer.GetReader(0);
}
MoveToSecurityHeader(messageReader, securityHeader.HeaderIndex, true);
this.cachedReaderAtSecurityHeader = messageReader;
this.state = BodyState.Buffered;
}
else
{
this.envelopeAttributes = XmlAttributeHolder.emptyArray;
this.headerAttributes = XmlAttributeHolder.emptyArray;
this.bodyAttributes = XmlAttributeHolder.emptyArray;
this.canDelegateCreateBufferedCopyToInnerMessage = true;
}
}
internal static void CleanBuffer()
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_CleanBuffer.Begin();
#endif
foreach (var pair in s_BufferQueues)
{
while (pair.Value.Count > 0 && Time.realtimeSinceStartup - pair.Value.Peek().BufferTime >= NetworkManager.Singleton.NetworkConfig.MessageBufferTimeout)
{
BufferedMessage message = pair.Value.Dequeue();
RecycleConsumedBufferedMessage(message);
}
if (pair.Value.Count == 0)
{
s_KeysToDestroy.Add(pair.Key);
}
}
for (int i = 0; i < s_KeysToDestroy.Count; i++)
{
s_BufferQueues.Remove(s_KeysToDestroy[i]);
}
s_KeysToDestroy.Clear();
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_CleanBuffer.End();
#endif
}
public override Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType)
{
if (bufferManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(bufferManager));
}
Message message;
UTF8BufferedMessageData messageData = TakeBufferedReader();
messageData.Encoding = GetEncodingFromContentType(contentType, _contentEncodingMap);
messageData.Open(buffer, bufferManager);
RecycledMessageState messageState = messageData.TakeMessageState();
if (messageState == null)
{
messageState = new RecycledMessageState();
}
message = new BufferedMessage(messageData, messageState);
message.Properties.Encoder = this;
return(message);
}
public void ReleaseAt()
{
var expected = DateTime.UtcNow;
var obj = new BufferedMessage()
{
ReleaseAt = expected
};
Assert.AreEqual(expected, obj.ReleaseAt);
}
public void Data()
{
var expected = Guid.NewGuid().ToString();
var obj = new BufferedMessage()
{
Data = expected
};
Assert.AreEqual(expected, obj.Data);
}
/// <summary>
/// Send Message for Buffer
/// </summary>
/// <param name="message">Message</param>
/// <param name="enqueueAt">Schedule for Enqueue</param>
/// <param name="offset">Offset</param>
/// <returns>Task</returns>
public virtual async Task SendBuffered(object data, DateTime releaseAt, sbyte offset = BufferedOffset)
{
var message = new BufferedMessage
{
Data = null == data ? null : JsonConvert.SerializeObject(data),
ReleaseAt = releaseAt
};
await this.Send(message, releaseAt.AddSeconds(offset));
}
/// <summary>
/// Process Buffered Message
/// </summary>
/// <param name="buffered">Buffered</param>
/// <returns>Successful</returns>
public async Task <bool> Process(BufferedMessage buffered)
{
var obj = string.IsNullOrWhiteSpace(buffered.Data) ? default(T) : JsonConvert.DeserializeObject <T>(buffered.Data);
Trace.TraceInformation("{1}: Message timing: {0} before scheduled release.", buffered.ReleaseAt.Subtract(DateTime.UtcNow), this.eventHandler.GetType());
this.sleep.Until(buffered.ReleaseAt);
Trace.TraceInformation("{1}: Message timing: {0} afer scheduled release.", DateTime.UtcNow.Subtract(buffered.ReleaseAt), this.eventHandler.GetType());
return(await this.eventHandler.Process(obj));
}
public override Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType)
{
if (bufferManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(bufferManager));
}
if (contentType == ContentType)
{
contentType = null;
}
// if (WcfEventSource.Instance.MtomMessageDecodingStartIsEnabled())
// {
// WcfEventSource.Instance.MtomMessageDecodingStart();
// }
MtomBufferedMessageData messageData = _factory.TakeBufferedReader(this);
messageData._contentType = contentType;
messageData.Open(buffer, bufferManager);
RecycledMessageState messageState = messageData.TakeMessageState();
if (messageState == null)
{
messageState = new RecycledMessageState();
}
Message message = new BufferedMessage(messageData, messageState);
message.Properties.Encoder = this;
// if (MessageLogger.LogMessagesAtTransportLevel)
// MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
//
// if (WcfEventSource.Instance.MessageReadByEncoderIsEnabled() && buffer != null)
// {
// WcfEventSource.Instance.MessageReadByEncoder(
// EventTraceActivityHelper.TryExtractActivity(message, true),
// buffer.Count,
// this);
// }
return(message);
}
public override Message CreateMessage()
{
lock (ThisLock)
{
if (closed)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
}
RecycledMessageState recycledMessageState = messageData.TakeMessageState();
if (recycledMessageState == null)
{
recycledMessageState = new RecycledMessageState();
}
BufferedMessage bufferedMessage = new BufferedMessage(messageData, recycledMessageState, understoodHeaders, understoodHeadersModified);
bufferedMessage.Properties.CopyProperties(properties);
messageData.Open();
return(bufferedMessage);
}
}
public ITempNetObject SpawnNewTempNetObject(int prefabID, Vector3 pos, Quaternion rot)
{
TempObjID newID = new TempObjID(nextNum, prefabID);
nextNum++;
ITempNetObject comp = CreateLocalNetObject(prefabID, newID, pos, rot);
// send the creation message
NetWriter writer = NetworkManager.StartNetworkMessage("create_temp_obj", thisNetworkID);
newID.WriteBytes(writer);
writer.WriteVector3(comp.GetPosition());
writer.WriteVector3(comp.GetEulerAngles());
comp.WriteInitialBytes(writer);
BufferedMessage msg = NetworkManager.SendMessageToOtherClients(writer, NetworkCore.ReliableSequencedMsg, true);
comp.SetNetMessage(msg);
mapping.Add(newID, comp);
return(comp);
}
/// <summary>
/// Sends the message to all clients except our local one.
/// /// Messages sent in this way can be buffered into a queue, so that they are executed on all new clients in order.
/// </summary>
/// <param name="_writer">Writer.</param>
/// <param name="channelType">Channel type.</param>
/// <param name="addToBuffer"> add this message to the buffer</param>
/// <returns>The Buffered Message if one was added.</returns>
public static BufferedMessage SendMessageToOtherClients(NetWriter _writer, int channelType, bool addToBuffer)
{
writer.StopWriting();
if (!NetworkCore.isServer)
{
Debug.LogError("Tried to send message to other clients, but we are not a server!");
return(null);
}
int writtenSize = _writer.GetWrittenBytes();
byte[] rawData = _writer.GetRawData();
NetworkCore.singleton.SendRawToOtherClients(channelType, rawData, writtenSize);
if (addToBuffer)
{
BufferedMessage msg = new BufferedMessage(channelType, (byte[])rawData.Clone(), writtenSize, false);
bufferedMessages.Add(msg);
return(msg);
}
return(null);
}
/// <summary>
/// Instantiates a prefab and assigns a network ID to it.
/// This is replicated across all peers, and is buffered for any new players.
/// To destroy these objects, you should use the "NetworkDestroy" function.
/// </summary>
/// <param name="pos">Position.</param>
/// <param name="rot">Rot.</param>
public GameObject NetworkInstantiate(NetworkPrefab prefab, Vector3 pos, Quaternion rot, bool sendToLocalClient)
{
if (NetworkCore.isServer)
{
if (prefab == null)
{
Debug.LogError("NetworkInstantiate called with no prefab. Object not created");
return(null);
}
GameObject newObj = Instantiate(prefab.serverPrefab, pos, rot);
NetObjectID idComp = newObj.GetComponent <NetObjectID>();
NetworkID newID = GetNextID(idComp);
idComp.SetNetID(newID);
NetWriter writer = StartNetworkMessage("cl_NetworkInstantiate", thisNetworkID);
writer.WriteInt(prefab.id);
writer.WriteVector3(pos);
writer.WriteVector3(rot.eulerAngles);
newID.WriteBytes(writer);
BufferedMessage msg = null;
if (sendToLocalClient)
{
msg = SendMessageToAllClients(writer, NetworkCore.AllCostMsg, true);
}
else
{
msg = SendMessageToOtherClients(writer, NetworkCore.AllCostMsg, true);
}
if (msg == null)
{
Debug.Log("Failed to successfully send Instantiation message. Unregistering Network ID: " + newID.ToString());
FreeNetworkID(idComp);
return(newObj);
}
idComp.AddBufferedMessage(msg);
newObj.BroadcastMessage("OnNewNetworkSceneLoaded");
return(newObj);
}
return(null);
}
public async Task ProcessDataNull()
{
var data = Guid.Empty;
var msg = new BufferedMessage()
{
ReleaseAt = DateTime.UtcNow,
Data = null,
};
var handler = Substitute.For <IBusEventHandler <Guid> >();
handler.Process(data).Returns(Task.FromResult(true));
var sleep = Substitute.For <ISleep>();
sleep.Until(msg.ReleaseAt);
var h = new BufferedMessageEventHandler <Guid>(handler, sleep);
var s = await h.Process(msg);
Assert.IsTrue(s);
sleep.Received().Until(msg.ReleaseAt);
handler.Received().Process(data);
}
internal static void CleanBuffer()
{
foreach (KeyValuePair <ulong, Queue <BufferedMessage> > pair in bufferQueues)
{
while (pair.Value.Count > 0 && Time.realtimeSinceStartup - pair.Value.Peek().bufferTime >= NetworkingManager.Singleton.NetworkConfig.MessageBufferTimeout)
{
BufferedMessage message = pair.Value.Dequeue();
RecycleConsumedBufferedMessage(message);
}
if (pair.Value.Count == 0)
{
_keysToDestroy.Add(pair.Key);
}
}
for (int i = 0; i < _keysToDestroy.Count; i++)
{
bufferQueues.Remove(_keysToDestroy[i]);
}
_keysToDestroy.Clear();
}
internal static void RecycleConsumedBufferedMessage(BufferedMessage message)
{
message.payload.Dispose();
}
public void SetNetMessage(BufferedMessage msg)
{
bufMsg = msg;
}
public override Message Empty()
{
BufferedMessage item = new BufferedMessage(CommandType.Null, 0, 0);
return(item);
}
internal static void RecycleConsumedBufferedMessage(BufferedMessage message)
{
message.NetworkBuffer.Dispose();
}
internal void AddBufferedMessage(BufferedMessage msg)
{
bufferedMessages.Add(msg);
}
public static bool RemoveBufferedMessage(BufferedMessage message)
{
return(bufferedMessages.Remove(message));
}
