private void RespawnPlayer(MessageMetaData metadata, GameMessages.RespawnPlayerRequest respawnRequest)
{
var ownerConnectionId = metadata.ConnectionId;
PlayerInfo playerInfo;
if (ownerConnectionId == ConnectionId.Self)
{
playerInfo = _serverPlayerInfo;
}
else if (!_connectedClients.TryGetValue(ownerConnectionId, out playerInfo))
{
Debug.LogWarning("unable to find player info for " + ownerConnectionId);
playerInfo = new PlayerInfo("", "", false, false);
}
DespawnPlayer(metadata, null);
var pilot = _networkSystems.Replicator.Instantiate(ReplicationObjects.Pilot, ownerConnectionId,
respawnRequest.Spawnpoint.Position, respawnRequest.Spawnpoint.Rotation);
//PlayerPilotSpawner.JumpForward(respawnRequest, pilot);
// TODO Communicate player information to the player instance such that we can
// render name tags and avatars etc.
// var playerInfoMessage = new PilotMessage.SetPlayerInfo();
// playerInfoMessage.PlayerInfo = playerInfo;
// pilot.GameObject.GetComponentInChildren<PilotPlayerInfoView>(includeInactive: true).SetPlayerInfo(playerInfoMessage);
_networkSystems.Replicator.Activate(pilot);
}
/// <summary>
/// Puts a message with two payloads to the Holodeck endpoint referencing the given <paramref name="pmodeId"/>.
/// </summary>
/// <param name="pmodeId">The pmode id the message should have as reference.</param>
public void PutMessageTwoPayloadsToHolodeckA(string pmodeId)
{
var msg = new MessageMetaData
{
CollaborationInfo = new HolodeckCollaborationInfo
{
AgreementRef = new HolodeckAgreementRef {
PMode = pmodeId
},
ConversationId = "org:holodeckb2b:test:conversation"
},
PayloadInfo = new HolodeckPayloadInfo
{
PartInfo = new[]
{
SubmitImagePayload,
SubmitXmlPayload
}
}
};
string xml = AS4XmlSerializer.ToString(msg);
string path = Path.Combine(HolodeckALocations.OutputPath, $"{pmodeId}-sample.mmd");
File.WriteAllText(path, xml);
}
public Fixture()
{
this.Message = new TestMessage()
{
Id = Guid.NewGuid(),
Description = "Test Message Text",
Name = "Test Message Name",
MessageDate = DateTime.UtcNow,
};
this.MessageMetaData = new MessageMetaData(delay: TimeSpan.FromSeconds(10), correlationId: this.Message.Id.ToString(), messageId: this.Message.Id.ToString(), skipTransient: true);
string messageBody = JsonConvert.SerializeObject(this.Message);
this.SerializedMessageMetaData = this.MessageMetaData != null?JsonConvert.SerializeObject(this.MessageMetaData) : null;
this.MessageBytes = Encoding.UTF8.GetBytes(messageBody);
this.Outbox = new Outbox <ApplicationDbContext>(new OutboxSettings()
{
BatchSize = 10,
MaxConcurrency = 1,
MaxTries = 10,
SqlConnectionString = ConnectionString,
DisableTransientDispatch = false,
});
var handlerFactory = A.Fake <IServiceFactory>();
this.MessagingService = new MessagingService(this.Outbox, handlerFactory);
}
private void OnClockSync(MessageMetaData metadata, BasicMessage.Pong pong)
{
bool isPongReceived = false;
for (int i = _outstandingPings.Count - 1; i >= 0; i--)
{
var outstandingPing = _outstandingPings[i];
// Handle the ping frame, set the clocks remove any old outstanding pings
if (outstandingPing.FrameId == pong.FrameId)
{
_roundTripTime = (float)(_localRealtimeClock.CurrentTime - outstandingPing.Timestamp);
var latency = _roundTripTime / 2f;
// TODO Add latency smoothing
_latencyInfo.UpdateLatency(metadata.ConnectionId, latency);
isPongReceived = true;
}
if (isPongReceived)
{
_outstandingPings.RemoveAt(i);
}
}
}
public async Task Should_expire_on_service_bus_queue()
{
var message = new TestMessage()
{
Id = Guid.NewGuid(),
Description = "Test Expire Queue",
MessageDate = DateTime.Now,
Name = "Queue Delay",
};
var messageBytes = IntegrationTestFixture.Serialize(message);
var fakeHandler = A.Fake <ITestMessageHandler>();
A.CallTo(() => fakeHandler.HandleMessage(A <Message> .Ignored, A <CancellationToken> .Ignored)).Returns(Task.CompletedTask);
A.CallTo(() => fakeHandler.HandleException(A <ExceptionReceivedEventArgs> .Ignored)).Returns(Task.CompletedTask);
var meta = new MessageMetaData(expiresAtUtc: DateTime.UtcNow.AddSeconds(10), messageId: message.Id.ToString());
await IntegrationTestFixture.Transport.Dispatch(message.MessageType, messageBytes, IntegrationTestFixture.QueueEndpoint, meta);
await Task.Delay(12000);
var client = IntegrationTestFixture.ReadFromQueue(IntegrationTestFixture.QueueEndpoint, fakeHandler);
await Task.Delay(3000);
A.CallTo(() => fakeHandler.HandleMessage(
A <Message> .That.Matches(x =>
x.MessageId.Equals(message.Id.ToString()) &&
x.Body.SequenceEqual(messageBytes)
),
A <CancellationToken> .Ignored
)).MustNotHaveHappened();
await client.CloseAsync();
}
public async Task CreateOutboxMessages(int count)
{
using (var scope = NewScope())
{
var db = scope.ServiceProvider.GetService<ApplicationDbContext>();
for (int i = 0; i < count; i++)
{
var messageMetaData = new MessageMetaData(messageId: i.ToString());
var serializedMessageMetaData = messageMetaData != null ? JsonConvert.SerializeObject(messageMetaData) : null;
OutboxMessage om = new OutboxMessage(
Message.MessageType,
MessageBytes,
serializedMessageMetaData,
DateTime.UtcNow,
"Test",
true,
null
);
db.Set<OutboxMessage>().Add(om);
}
await db.SaveChangesAsync();
}
}
public void Should_map_messagetype_to_label()
{
Message m = new Message();
MessageMetaData md = new MessageMetaData();
Mapper.ApplyMetaData(m, md, MessageType);
m.Label.ShouldBe(MessageType);
}
public IntegrationMessageFilterContext(IIntegrationMessage message, MessageMetaData meta, IEndpoint endpoint, FilterDirection direction, MessageTypeProperties props)
{
Message = message;
MessageMetaData = meta;
Endpoint = endpoint;
Direction = direction;
Props = props;
}
public MessageMetaData ExtractMetaData(Message message)
{
MessageMetaData meta = new MessageMetaData();
if (!String.IsNullOrEmpty(message.Label))
{
meta.MessageType = message.Label;
}
if (!String.IsNullOrEmpty(message.MessageId))
{
meta.MessageId = message.MessageId;
}
try
{
//message throws exception if not in a state where expiration can be calculated
if (message.ExpiresAtUtc != default(DateTime))
{
meta.ExpiresAtUtc = message.ExpiresAtUtc;
}
}
catch { }
if (message.UserProperties.ContainsKey("OriginalMessageId"))
{
var messageId = (string)message.UserProperties["OriginalMessageId"];
meta.MessageId = messageId;
meta.Add("TransientMessageId", message.MessageId);
}
if (!String.IsNullOrEmpty(message.ContentType))
{
meta.ContentType = message.ContentType;
}
if (!String.IsNullOrEmpty(message.CorrelationId))
{
meta.CorrelationId = message.CorrelationId;
}
if (!String.IsNullOrEmpty(message.ReplyTo))
{
meta.ReplyTo = message.ReplyTo;
}
if (!String.IsNullOrEmpty(message.SessionId))
{
meta.SessionId = message.SessionId;
}
foreach (var item in message.UserProperties)
{
meta[item.Key] = item.Value != null?item.Value.ToString() : null;
}
return(meta);
}
public void Should_map_messageid_to_messagid()
{
string messageId = "123";
Message m = new Message();
MessageMetaData md = new MessageMetaData(messageId: messageId);
Mapper.ApplyMetaData(m, md, MessageType);
m.MessageId.ShouldBe(messageId);
}
public void Should_ignore_null_values_in_constructor()
{
MessageMetaData md = new MessageMetaData();
md.ContainsKey(HeaderType.MessageId.Value).ShouldBeFalse();
md.ContainsKey(HeaderType.DispatchDelay.Value).ShouldBeFalse();
md.ContainsKey(HeaderType.CorrelationId.Value).ShouldBeFalse();
md.ContainsKey(HeaderType.ExpiresAtUtc.Value).ShouldBeFalse();
}
public void Should_map_correlationid_to_correlationid()
{
string correlationid = "567";
Message m = new Message();
MessageMetaData md = new MessageMetaData(correlationId: correlationid);
Mapper.ApplyMetaData(m, md, MessageType);
m.CorrelationId.ShouldBe(correlationid);
}
public void Should_map_custom_metadata_to_properties()
{
var customKey = "Custom1";
var customVal = "Custom1Value";
Message m = new Message();
MessageMetaData md = new MessageMetaData();
md.Add(customKey, customVal);
Mapper.ApplyMetaData(m, md, MessageType);
m.UserProperties[customKey].ShouldBe(customVal);
}
public Message CloneWithoutValue()
{
Message messageEntry = new Message(_messageId);
lock (this)
{
messageEntry.CreationTime = CreationTime;
messageEntry.FlagMap = (BitSet)FlagMap.Clone();
messageEntry.MessageMetaData = (MessageMetaData)MessageMetaData.Clone();
}
return(messageEntry);
}
public void Should_map_encrypted_to_properties()
{
var encrypted = true;
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
Encrypted = encrypted
};
Mapper.ApplyMetaData(m, md, MessageType);
m.UserProperties["Encrypted"].ShouldBe("True");
}
public void Should_map_skipTransientDispatch_to_properties()
{
var skipTransientDispatch = true;
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
SkipTransientDispatch = skipTransientDispatch
};
Mapper.ApplyMetaData(m, md, MessageType);
m.UserProperties["SkipTransientDispatch"].ShouldBe("True");
}
public void Should_map_createdat_to_properties()
{
var createdAt = DateTime.UtcNow;
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
CreatedAtUtc = createdAt
};
Mapper.ApplyMetaData(m, md, MessageType);
m.UserProperties["CreatedAtUtc"].ShouldBe(createdAt.ToString("o"));
}
public virtual void Serialize(CompactWriter writer)
{
lock (this)
{
writer.WriteObject(_messageId);
writer.WriteObject(PayLoad);
writer.WriteObject(FlagMap);
writer.Write(_size);
writer.Write(CreationTime);
MessageMetaData.WriteMetaDataInfo(writer, MessageMetaData);
}
}
public void Should_map_encryptionMethod_to_properties()
{
var encryptionMethod = "AES";
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
EncryptionMethod = encryptionMethod
};
Mapper.ApplyMetaData(m, md, MessageType);
m.UserProperties[HeaderType.EncryptionMethod.Value].ShouldBe(encryptionMethod);
}
public void Should_map_encryptionKeyName_to_properties()
{
var encryptionKeyName = "eventEncryptionKey";
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
EncryptionKeyName = encryptionKeyName
};
Mapper.ApplyMetaData(m, md, MessageType);
m.UserProperties[HeaderType.EncryptionKeyName.Value].ShouldBe(encryptionKeyName);
}
public virtual void Deserialize(CompactReader reader)
{
lock (this)
{
_messageId = reader.ReadObject() as string;
PayLoad = reader.ReadObject();
FlagMap = reader.ReadObject() as BitSet;
_size = reader.ReadInt64();
CreationTime = reader.ReadDateTime();
MessageMetaData = MessageMetaData.ReadMetaDataInfo(reader);
}
}
public void Should_map_replyToEndpointName_to_properties()
{
var replyToEndpointName = "Replies";
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
ReplyToEndpointName = replyToEndpointName
};
Mapper.ApplyMetaData(m, md, MessageType);
m.UserProperties["ReplyToEndpointName"].ShouldBe(replyToEndpointName);
}
public void Should_map_timetolive_to_timetolive()
{
var timetolive = TimeSpan.FromSeconds(30);
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
TimeToLive = timetolive
};
Mapper.ApplyMetaData(m, md, MessageType);
m.TimeToLive.ShouldBe(timetolive);
}
public void Should_map_sessionId_to_sessionId()
{
string sessionId = "endpoint://address";
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
SessionId = sessionId
};
Mapper.ApplyMetaData(m, md, MessageType);
m.SessionId.ShouldBe(sessionId);
}
public void Should_map_replyto_to_replyto()
{
string replyto = "endpoint://address";
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
ReplyTo = replyto
};
Mapper.ApplyMetaData(m, md, MessageType);
m.ReplyTo.ShouldBe(replyto);
}
public void Should_map_contenttype_to_contenttype()
{
string contenttype = "text/json";
Message m = new Message();
MessageMetaData md = new MessageMetaData()
{
ContentType = contenttype
};
Mapper.ApplyMetaData(m, md, MessageType);
m.ContentType.ShouldBe(contenttype);
}
private MessageMetaData GetMessageMetaData(HtmlNode messageNode)
{
var metaData = new MessageMetaData();
var messageTime = ExtractMessageTime(messageNode);
metaData.Timestamp = CreateFullDate(currentDate, messageTime);
string messageAuthor = ExtractMessageAuthor(messageNode);
metaData.Sender = GetUser(messageAuthor);
return(metaData);
}
public object Clone()
{
Message messageEntry = new Message(_messageId);
lock (this)
{
messageEntry.CreationTime = CreationTime;
messageEntry.PayLoad = PayLoad;
messageEntry.FlagMap = (BitSet)FlagMap.Clone();
messageEntry.MessageMetaData = (MessageMetaData)MessageMetaData.Clone();
}
return(messageEntry);
}
private void DespawnPlayer(MessageMetaData metadata, GameMessages.DespawnPlayerRequest despawnRequest)
{
var ownerConnectionId = metadata.ConnectionId;
_replicatedObjectsCache.Clear();
_networkSystems.ObjectStore.FindObjects(ReplicationObjects.Pilot, _replicatedObjectsCache);
_replicatedObjectsCache.FilterOwner(ownerConnectionId);
if (_replicatedObjectsCache.Count > 0)
{
var existingPilot = _replicatedObjectsCache[0];
_networkSystems.Replicator.RemoveReplicatedInstance(existingPilot.Id);
}
}
public void Should_calculate_expiration()
{
var now = DateTime.UtcNow;
var future = now.AddSeconds(1);
var past = now.AddSeconds(-1);
MessageMetaData md = new MessageMetaData()
{
ExpiresAtUtc = now
};
md.IsExpired(future).ShouldBeTrue();
md.IsExpired(past).ShouldBeFalse();
md.IsExpired(now).ShouldBeTrue(); //expirate <=
}
