public static WebhookCommand DetermineWebhookCommand(MessageContentType messageContentType, WebhookCacheOperation webhookCacheOperation)
{
switch (webhookCacheOperation)
{
case WebhookCacheOperation.CreateOrUpdate:
switch (messageContentType)
{
case MessageContentType.LmiSocSummary:
return(WebhookCommand.TransformAllSocToJobGroup);
case MessageContentType.LmiSocItem:
return(WebhookCommand.TransformSocToJobGroup);
}
break;
case WebhookCacheOperation.Delete:
switch (messageContentType)
{
case MessageContentType.LmiSocSummary:
return(WebhookCommand.PurgeAllJobGroups);
case MessageContentType.LmiSocItem:
return(WebhookCommand.PurgeJobGroup);
}
break;
}
return(WebhookCommand.None);
}
/// <summary>
/// Called when [init].
/// </summary>
/// <param name = "peer">The peer.</param>
/// <param name = "data">The data.</param>
public void OnInit(IPhotonPeer peer, byte[] data, byte channelCount)
{
try
{
if (log.IsDebugEnabled)
{
Encoding utf8Encoding = Encoding.UTF8;
log.DebugFormat("OnInit - {0}", utf8Encoding.GetString(data));
}
if (data[0] == '<' && data[21] == '>')
{
byte[] bytes = peer.GetLocalPort() == 943 ? this.silverlightPolicyBytesUtf8 : this.policyBytesUtf8;
// in case the policy app ever serves a websocket port...
MessageContentType contentType = peer.GetListenerType() == ListenerType.WebSocketListener
? MessageContentType.Text
: MessageContentType.Binary;
peer.Send(bytes, MessageReliablity.Reliable, 0, contentType);
if (log.IsDebugEnabled)
{
log.Debug("Policy sent.");
}
}
peer.DisconnectClient(); // silverlight does not disconnect by itself
}
catch (Exception e)
{
log.Error(e);
throw;
}
}
public static WebhookCommand DetermineWebhookCommand(MessageContentType messageContentType, WebhookCacheOperation webhookCacheOperation)
{
switch (webhookCacheOperation)
{
case WebhookCacheOperation.CreateOrUpdate:
switch (messageContentType)
{
case MessageContentType.Publish:
return(WebhookCommand.PublishFromDraft);
}
break;
case WebhookCacheOperation.Delete:
switch (messageContentType)
{
case MessageContentType.Publish:
return(WebhookCommand.PurgeFromPublished);
}
break;
}
return(WebhookCommand.None);
}
private void ReadData(NetIncomingMessage msgInc)
{
int id;
MessageContentType contentType = (MessageContentType)msgInc.ReadByte();
switch (contentType)
{
case MessageContentType.RequestSpawn:
Player newPlayer = new Player();
id = Map.AddObject(newPlayer);
NetOutgoingMessage msgOut = Server.CreateMessage();
msgOut.Write((byte)MessageContentType.ApproveSpawn);
msgOut.Write(id);
Server.SendMessage(msgOut, msgInc.SenderConnection, NetDeliveryMethod.ReliableUnordered);
break;
case MessageContentType.MapData:
GameObject obj;
id = msgInc.ReadInt32();
if (Map.Objects.TryGetValue(id, out obj))
{
msgInc.ReadByte(); // Ignore GameObjectType
obj.ReadFrom(msgInc);
}
break;
case MessageContentType.RequestProjectile:
Vector2 position = new Vector2(msgInc.ReadFloat(), msgInc.ReadFloat());
Vector2 velocity = new Vector2(msgInc.ReadFloat(), msgInc.ReadFloat());
SpawnProjectile(position, velocity);
break;
}
}
public static TSms AsType <TSms>(this TSms sms, MessageContentType type)
where TSms : Sms
{
Contract.Requires(sms != null);
Contract.Ensures(Contract.Result <TSms>() == sms);
return(sms.Assign(s => s.Type = type));
}
public void LmiWebhookReceiverServiceDetermineWebhookCommandReturnsExpected(MessageContentType messageContentType, WebhookCacheOperation webhookCacheOperation, WebhookCommand expectedResult)
{
// Arrange
// Act
var result = LmiWebhookReceiverService.DetermineWebhookCommand(messageContentType, webhookCacheOperation);
// Assert
Assert.Equal(expectedResult, result);
}
private void ReadData(NetIncomingMessage msg)
{
MessageContentType contentType = (MessageContentType)msg.ReadByte();
switch (contentType)
{
case MessageContentType.StartGame:
Game.ActiveState = new ClientBattleGameState(Game);
break;
}
}
/// <summary>
/// OnReceive callback.
/// </summary>
/// <param name = "peer">
/// The peer.
/// </param>
/// <param name = "userData">
/// The user data.
/// </param>
/// <param name = "data">
/// The data.
/// </param>
/// <param name = "reliability">
/// The reliability.
/// </param>
/// <param name = "channelId">
/// The channel id.
/// </param>
/// /// <param name = "rtt">The round trip time.</param>
/// <param name = "rttVariance">The round trip time variance.</param>
/// <param name = "numFailures">The number of failures. </param>
public void OnReceive(
IPhotonPeer peer,
object userData,
byte[] data,
MessageReliablity reliability,
byte channelId,
MessageContentType messageContentType,
int rtt,
int rttVariance,
int numFailures)
{
}
public bool BroadcastEvent(IPhotonPeer[] peerList, byte[] data, MessageReliablity reliability, byte channelId, MessageContentType messageContentType, out SendResults[] results)
{
results = new SendResults[peerList.Length];
for (int i = 0; i < peerList.Length; i++)
{
results[i] = peerList[i].Send(data, reliability, channelId, messageContentType);
}
return true;
}
static public MemoryStream Deserialize(MemoryStream ms, MessageContentType msgContentType)
{
if (msgContentType == MessageContentType.Xml)
{
return(ms); // Either already in XML or an explicit serialization will be called by Comm. Manager
}
else if (msgContentType == MessageContentType.FastInfoSet)
{
return(FastInfoSetSerializer.DeSerialize(ms));
}
throw new ArgumentOutOfRangeException("msgContentType");
}
public async Task MessageHandlerReturnsExceptionWhenEmptyServiceBusMessageSupplied()
{
// arrange
const MessageAction messageAction = MessageAction.Published;
const MessageContentType messageContentType = MessageContentType.Pages;
var serviceBusMessage = new Message(Encoding.ASCII.GetBytes(string.Empty));
serviceBusMessage.UserProperties.Add("ActionType", messageAction);
serviceBusMessage.UserProperties.Add("CType", messageContentType);
serviceBusMessage.UserProperties.Add("Id", Guid.NewGuid());
// act
await Assert.ThrowsAsync <ArgumentException>(async() => await MessageHandler.Run(serviceBusMessage, messageProcessor, messagePropertiesService, logger).ConfigureAwait(false)).ConfigureAwait(false);
}
public async Task MessageHandlerReturnsExceptionWhenMessageActionIsInvalid()
{
// arrange
const int messageAction = -1;
const MessageContentType messageContentType = MessageContentType.Pages;
var model = A.Fake <ContentPageMessage>();
var message = JsonConvert.SerializeObject(model);
var serviceBusMessage = new Message(Encoding.ASCII.GetBytes(message));
serviceBusMessage.UserProperties.Add("ActionType", messageAction);
serviceBusMessage.UserProperties.Add("CType", messageContentType);
serviceBusMessage.UserProperties.Add("Id", Guid.NewGuid());
// act
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => await MessageHandler.Run(serviceBusMessage, messageProcessor, messagePropertiesService, logger).ConfigureAwait(false)).ConfigureAwait(false);
}
public async Task ProcessAsyncWithBadMessageMessageActionReturnsException()
{
// arrange
const string message = "{}";
const long sequenceNumber = 1;
const MessageContentType messageContentType = MessageContentType.Pages;
A.CallTo(() => mappingService.MapToContentPageModel(message, sequenceNumber)).Returns(A.Fake <ContentPageModel>());
// act
var exceptionResult = await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => await messageProcessor.ProcessAsync(message, sequenceNumber, messageContentType, (MessageAction)(-1)).ConfigureAwait(false)).ConfigureAwait(false);
// assert
A.CallTo(() => mappingService.MapToContentPageModel(message, sequenceNumber)).MustHaveHappenedOnceExactly();
Assert.Equal("Invalid message action '-1' received, should be one of 'Published,Deleted,Draft' (Parameter 'messageAction')", exceptionResult.Message);
}
public void SendMessage(MessageContentType type, int player, IMessageContent data)
{
lock (messageLock)
{
NetworkMessage msg;
if (data != null)
{
msg = new NetworkMessage(data, type);
SendBuffer(msg.Encode(), player);
}
else
{
SendBuffer(NetworkMessage.EmptyMessage(type), player);
}
}
}
public async Task SitefinityMessageHandlerReturnsExceptionWhenMessageActionIsInvalid()
{
// arrange
const int messageAction = -1;
const MessageContentType messageContentType = MessageContentType.WorkingHoursDetails;
var model = A.Fake <PatchWorkingHoursDetailModel>();
var message = JsonConvert.SerializeObject(model);
var serviceBusMessage = new Message(Encoding.ASCII.GetBytes(message));
serviceBusMessage.UserProperties.Add("ActionType", messageAction);
serviceBusMessage.UserProperties.Add("CType", messageContentType);
serviceBusMessage.UserProperties.Add("Id", Guid.NewGuid());
// act
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => await sitefinityMessageHandler.Run(serviceBusMessage).ConfigureAwait(false)).ConfigureAwait(false);
}
static public MemoryStream Serialize(MemoryStream ms, MessageContentType msgContentType)
{
if (ms == null)
{
throw new ArgumentNullException("ms");
}
if (msgContentType == MessageContentType.Xml)
{
return(ms); // Already in XML
}
else if (msgContentType == MessageContentType.FastInfoSet)
{
return(FastInfoSetSerializer.Serialize(ms));
}
throw new ArgumentOutOfRangeException("msgContentType");
}
public async Task ProcessAsyncRequirementTestReturnsOk(MessageContentType messageContentType)
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.OK;
const string message = "{}";
const long sequenceNumber = 1;
A.CallTo(() => mapper.Map <PatchRequirementsModel>(A <PatchRequirementsServiceBusModel> .Ignored)).Returns(A.Fake <PatchRequirementsModel>());
A.CallTo(() => httpClientService.PatchAsync(A <PatchRequirementsModel> .Ignored, A <string> .Ignored)).Returns(expectedResult);
// act
var result = await messageProcessor.ProcessAsync(message, sequenceNumber, messageContentType, MessageAction.Published).ConfigureAwait(false);
// assert
A.CallTo(() => mapper.Map <PatchRequirementsModel>(A <PatchRequirementsServiceBusModel> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => httpClientService.PatchAsync(A <PatchRequirementsModel> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResult, result);
}
public static WebhookCommand DetermineWebhookCommand(MessageContentType messageContentType, WebhookCacheOperation webhookCacheOperation)
{
switch (webhookCacheOperation)
{
case WebhookCacheOperation.CreateOrUpdate:
switch (messageContentType)
{
case MessageContentType.JobGroup:
return(WebhookCommand.ReportDeltaForAll);
case MessageContentType.JobGroupItem:
return(WebhookCommand.ReportDeltaForSoc);
}
break;
}
return(WebhookCommand.None);
}
public async Task ProcessAsyncJobProfileDeletedTestReturnsOk()
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.OK;
const string message = "{}";
const long sequenceNumber = 1;
const MessageContentType messageContentType = MessageContentType.Pages;
A.CallTo(() => mappingService.MapToContentPageModel(message, sequenceNumber)).Returns(A.Fake <ContentPageModel>());
A.CallTo(() => httpClientService.DeleteAsync(A <Guid> .Ignored)).Returns(expectedResult);
// act
var result = await messageProcessor.ProcessAsync(message, sequenceNumber, messageContentType, MessageAction.Deleted).ConfigureAwait(false);
// assert
A.CallTo(() => mappingService.MapToContentPageModel(message, sequenceNumber)).MustHaveHappenedOnceExactly();
A.CallTo(() => httpClientService.DeleteAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResult, result);
}
public bool SendMessage(Byte[] data, MessageContentType contentType)
{
int opcodes = 0;
if (contentType == MessageContentType.Binary)
{
opcodes = Opcodes.BinaryFrame;
}
else if (contentType == MessageContentType.Text)
{
opcodes = Opcodes.TextFrame;
}
else
{
logger.Warn("不支持的命令格式：" + contentType.ToString());
return(false);
}
if (!IsConnected())
{
Debug.WriteLine("连接已断开，无法发送命令");
return(false);
}
FrameCommandBase command = WebSocketCommandFactory.CreateCommand(data, opcodes);
//Debug.WriteLine("Client Socket Status(SendMessage)：" + SessionID + " " + ClientSocket.Connected.ToString());
Protocol.WriteCommand(command as INetCommand, this);
//if (isClosed || (clientSocket != null && !clientSocket.Connected))
//{
// logger.Warn("连接已断开，命令未正确写入");
// return false;
//}
logger.Trace("SendCommand：{0} {1}\r\n{2}", SessionID, EndPoint, command);
//lock (objLock)
//{
// SendingMessages++;
//}
return(true);
}
public static void Serialize(object obj, Stream stm, MessageContentType contentType)
{
if (contentType == MessageContentType.Text)
{
SerializeText(obj, stm);
}
else if (contentType == MessageContentType.SerializedBinary)
{
//SoapFormatter bf = new SoapFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Persistence));
BinaryFormatter bf = new BinaryFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Persistence));
bf.Serialize(stm, obj);
}
else if (contentType == MessageContentType.SerializedSoap)
{
//SoapFormatter bf = new SoapFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Persistence));
//bf.Serialize(stm, obj);
throw new NotImplementedException();
}
else if (contentType == MessageContentType.Binary)
{
Stream input = obj as Stream;
if (input == null)
{
byte[] data = obj as byte[];
if (data != null)
input = new MemoryStream(data);
else
throw new Exception("Only byte[] or Stream object is allowed with binary content type");
}
byte[] buf = new byte[1000];
int n;
while ((n = input.Read(buf, 0, buf.Length)) > 0)
{
stm.Write(buf, 0, n);
}
}
else throw new ArgumentException("contentType");
}
public static object Deserialize(Stream stm, MessageContentType contentType)
{
if (contentType == MessageContentType.SerializedBinary)
{
BinaryFormatter bf = new BinaryFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Persistence));
return bf.Deserialize(stm);
}
else if (contentType == MessageContentType.SerializedSoap)
{
//SoapFormatter bf = new SoapFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Persistence));
//return bf.Deserialize(stm);
throw new NotImplementedException();
}
else if (contentType == MessageContentType.Text)
{
return DeserializeText(stm);
}
else if (contentType == MessageContentType.Binary)
{
return stm;
}
else throw new ArgumentException("contentType");
}
public async Task MessageHandlerReturnsSuccessForSegmentUpdated(HttpStatusCode expectedResult)
{
// arrange
const MessageAction messageAction = MessageAction.Published;
const MessageContentType messageContentType = MessageContentType.Pages;
const long sequenceNumber = 123;
var model = A.Fake <ContentPageMessage>();
var message = JsonConvert.SerializeObject(model);
var serviceBusMessage = new Message(Encoding.ASCII.GetBytes(message));
serviceBusMessage.UserProperties.Add("ActionType", messageAction);
serviceBusMessage.UserProperties.Add("CType", messageContentType);
serviceBusMessage.UserProperties.Add("Id", Guid.NewGuid());
A.CallTo(() => messagePropertiesService.GetSequenceNumber(serviceBusMessage)).Returns(sequenceNumber);
A.CallTo(() => messageProcessor.ProcessAsync(message, sequenceNumber, messageContentType, messageAction)).Returns(expectedResult);
// act
await MessageHandler.Run(serviceBusMessage, messageProcessor, messagePropertiesService, logger).ConfigureAwait(false);
// assert
A.CallTo(() => messagePropertiesService.GetSequenceNumber(serviceBusMessage)).MustHaveHappenedOnceExactly();
A.CallTo(() => messageProcessor.ProcessAsync(message, sequenceNumber, messageContentType, messageAction)).MustHaveHappenedOnceExactly();
}
/// <summary>
/// Constructs an instance of the <see cref="MessageBusMessage"/> class with the content type.
/// </summary>
/// <param name="contentType">The content type of the message.</param>
public MessageBusMessage(MessageContentType contentType)
: base(MessageType.Envelope, contentType)
{
}
public void LmiWebhookReceiverServiceDetermineMessageContentTypeReturnsExpected(string?apiEndpoint, MessageContentType expectedResult)
{
// Arrange
// Act
var result = LmiWebhookReceiverService.DetermineMessageContentType(apiEndpoint);
// Assert
Assert.Equal(expectedResult, result);
}
public async Task <HttpStatusCode> ProcessContentAsync(bool isDraft, Guid eventId, Guid?contentId, string?apiEndpoint, MessageContentType messageContentType)
{
if (!Uri.TryCreate(apiEndpoint, UriKind.Absolute, out Uri? url))
{
throw new InvalidDataException($"Invalid Api url '{apiEndpoint}' received for Event Id: {eventId}");
}
switch (messageContentType)
{
case MessageContentType.SharedContentItem:
logger.LogInformation($"Event Id: {eventId} - processing shared content for: {url}");
return(await ProcessSharedContentAsync(eventId, url).ConfigureAwait(false));
case MessageContentType.JobGroup:
if (isDraft)
{
logger.LogInformation($"Event Id: {eventId} - processing draft LMI SOC refresh for: {url}");
var result = await jobGroupCacheRefreshService.ReloadAsync(url).ConfigureAwait(false);
if (result == HttpStatusCode.OK || result == HttpStatusCode.Created)
{
await PostDraftEventAsync($"Draft all SOCs to delta-report API", eventGridClientOptions.ApiEndpoint, Guid.NewGuid()).ConfigureAwait(false);
}
return(result);
}
else
{
logger.LogInformation($"Event Id: {eventId} - processing published LMI SOC refresh from draft for: {url}");
return(await jobGroupPublishedRefreshService.ReloadAsync(url).ConfigureAwait(false));
}
case MessageContentType.JobGroupItem:
if (isDraft)
{
logger.LogInformation($"Event Id: {eventId} - processing draft LMI SOC item for: {url}");
var result = await jobGroupCacheRefreshService.ReloadItemAsync(url).ConfigureAwait(false);
if (result == HttpStatusCode.OK || result == HttpStatusCode.Created)
{
var eventGridEndpoint = new Uri($"{eventGridClientOptions.ApiEndpoint}/{contentId}", UriKind.Absolute);
await PostDraftEventAsync($"Draft individual SOC to delta-report API", eventGridEndpoint, contentId).ConfigureAwait(false);
}
return(result);
}
else
{
logger.LogInformation($"Event Id: {eventId} - processing published LMI SOC item from draft for: {url}");
return(await jobGroupPublishedRefreshService.ReloadItemAsync(url).ConfigureAwait(false));
}
}
return(HttpStatusCode.BadRequest);
}
public void WebhooksServiceDetermineMessageContentTypeReturnsExpected(string?apiEndpoint, MessageContentType expectedResponse)
{
// Arrange
// Act
var result = WebhooksService.DetermineMessageContentType(apiEndpoint);
// Assert
Assert.Equal(expectedResponse, result);
}
public ContentAttribute(MessageContentType type, MessageContentPersistFlag flag)
{
this.type = (int)type;
this.flag = flag;
}
public bool BroadcastEvent(IPhotonPeer[] peerList, byte[] data, MessageReliablity reliability, byte channelId, MessageContentType messageContentType, out SendResults[] results)
{
results = new SendResults[peerList.Length];
for (int i = 0; i < peerList.Length; i++)
{
results[i] = peerList[i].Send(data, reliability, channelId, messageContentType);
}
return(true);
}
public async Task <HttpStatusCode> ProcessDeleteAsync(Guid eventId, Guid contentId, MessageContentType messageContentType)
{
switch (messageContentType)
{
case MessageContentType.SharedContentItem:
logger.LogInformation($"Event Id: {eventId} - deleting shared content for: {contentId}");
return(await DeleteContentAsync(contentId).ConfigureAwait(false));
case MessageContentType.JobGroup:
logger.LogInformation($"Event Id: {eventId} - purging LMI SOC");
return(await PurgeSocAsync().ConfigureAwait(false));
case MessageContentType.JobGroupItem:
logger.LogInformation($"Event Id: {eventId} - deleting LMI SOC item {contentId}");
return(await DeleteSocItemAsync(contentId).ConfigureAwait(false));
}
return(HttpStatusCode.BadRequest);
}
public MessageContentEntity(MessageContentType type, string guid)
{
this.Type = type;
this.Guid = guid;
//this.Contents = contents;
}
/// <summary>
/// Constructs an instance of the <see cref="EventMessage"/> class with the content type.
/// </summary>
/// <param name="contentType">The content type of the message.</param>
public EventMessage(MessageContentType contentType)
: base(MessageType.Event, contentType)
{
}
public async Task <HttpStatusCode> ProcessAsync(string message, long sequenceNumber, MessageContentType messageContentType, MessageAction actionType)
{
switch (messageContentType)
{
case MessageContentType.JobProfileSoc:
var serviceBusJobProfileSocMessage = JsonConvert.DeserializeObject <PatchJobProfileSocServiceBusModel>(message);
var patchSocDataModel = mapper.Map <PatchJobProfileSocModel>(serviceBusJobProfileSocMessage);
patchSocDataModel.ActionType = actionType;
patchSocDataModel.SequenceNumber = sequenceNumber;
return(await httpClientService.PatchAsync(patchSocDataModel, $"{messageContentType}").ConfigureAwait(false));
case MessageContentType.ApprenticeshipFrameworks:
var serviceBusApprenticeshipFrameworksMessage = JsonConvert.DeserializeObject <PatchApprenticeshipFrameworksServiceBusModel>(message);
var patchApprenticeshipFrameworksModel = mapper.Map <PatchApprenticeshipFrameworksModel>(serviceBusApprenticeshipFrameworksMessage);
patchApprenticeshipFrameworksModel.ActionType = actionType;
patchApprenticeshipFrameworksModel.SequenceNumber = sequenceNumber;
return(await httpClientService.PatchAsync(patchApprenticeshipFrameworksModel, $"{messageContentType}").ConfigureAwait(false));
case MessageContentType.ApprenticeshipStandards:
var serviceBusApprenticeshipStandardsMessage = JsonConvert.DeserializeObject <PatchApprenticeshipStandardsServiceBusModel>(message);
var patchApprenticeshipStandardsModel = mapper.Map <PatchApprenticeshipStandardsModel>(serviceBusApprenticeshipStandardsMessage);
patchApprenticeshipStandardsModel.ActionType = actionType;
patchApprenticeshipStandardsModel.SequenceNumber = sequenceNumber;
return(await httpClientService.PatchAsync(patchApprenticeshipStandardsModel, $"{messageContentType}").ConfigureAwait(false));
case MessageContentType.JobProfile:
return(await ProcessJobProfileMessageAsync(message, actionType, sequenceNumber).ConfigureAwait(false));
default:
throw new ArgumentOutOfRangeException(nameof(messageContentType), $"Unexpected sitefinity content type '{messageContentType}'");
}
}
/// <summary>
/// Send data to the peer.
/// </summary>
/// <param name = "data">
/// The serialized data.
/// </param>
/// <param name = "reliability">
/// The reliability.
/// </param>
/// <param name = "channelId">
/// The channel id.
/// </param>
/// <returns>
/// Always <see cref = "SendResults.SentOk" />.
/// </returns>
public SendResults Send(byte[] data, MessageReliablity reliability, byte channelId, MessageContentType messageContentType)
{
RtsMessageHeader messageType;
if (this.Protocol.TryParseMessageHeader(data, out messageType) == false)
{
throw new InvalidOperationException();
}
switch (messageType.MessageType)
{
case RtsMessageType.Event:
{
EventData eventData;
if (this.Protocol.TryParseEventData(data, out eventData))
{
Interlocked.Increment(ref eventsReceived);
this.eventList.Add(eventData);
if (log.IsDebugEnabled)
{
if (eventData.Parameters.ContainsKey((byte)ParameterCode.ItemId))
{
log.DebugFormat(
"{0} receives event, {1} total - code {2}, source {3}",
this.username,
this.eventList.Count,
(EventCode)eventData.Code,
eventData.Parameters[(byte)ParameterCode.ItemId]);
}
else
{
log.DebugFormat(
"{0} receives event, {1} total - code {2}",
this.username,
this.eventList.Count,
(EventCode)eventData.Code);
}
}
}
else
{
throw new InvalidOperationException();
}
break;
}
case RtsMessageType.OperationResponse:
{
OperationResponse response;
if (this.Protocol.TryParseOperationResponse(data, out response))
{
Interlocked.Increment(ref responseReceived);
this.responseList.Add(response);
if (response.ReturnCode != (int)ReturnCode.Ok)
{
log.ErrorFormat(
"ERR {0}, OP {1}, DBG {2}", (ReturnCode)response.ReturnCode, (OperationCode)response.OperationCode, response.DebugMessage);
}
else if (log.IsDebugEnabled)
{
if (response.Parameters.ContainsKey((byte)ParameterCode.ItemId))
{
log.DebugFormat(
"{0} receives response, {1} total - code {2}, source {3}",
this.username,
this.responseList.Count,
(OperationCode)response.OperationCode,
response.Parameters[(byte)ParameterCode.ItemId]);
}
else
{
log.DebugFormat(
"{0} receives response, {1} total - code {2}",
this.username,
this.responseList.Count,
(OperationCode)response.OperationCode);
}
}
}
else
{
throw new InvalidOperationException();
}
break;
}
}
return SendResults.SentOk;
}
SendResults IPhotonPeer._InternalBroadcastSend(byte[] data, MessageReliablity reliability, byte channelId, MessageContentType messageContentType)
{
return new SendResults();
}
/// <summary>
/// The send.
/// </summary>
/// <param name = "data">
/// The data.
/// </param>
/// <param name = "reliability">
/// The reliability.
/// </param>
/// <param name = "channelId">
/// The channel id.
/// </param>
/// <param name="messageContentType">The message content type.</param>
/// <returns>
/// Always Ok.
/// </returns>
public SendResults Send(byte[] data, MessageReliablity reliability, byte channelId, MessageContentType messageContentType)
{
RtsMessageHeader messageType;
if (this.Protocol.TryParseMessageHeader(data, out messageType) == false)
{
throw new InvalidOperationException();
}
switch (messageType.MessageType)
{
case RtsMessageType.Event:
{
EventData eventData;
if (this.Protocol.TryParseEventData(data, out eventData))
{
this.fiber.Enqueue(
() =>
{
lock (this.syncRootEvents)
{
this.eventList.Add(eventData);
if (log.IsDebugEnabled)
{
log.DebugFormat(
"{0} receives event, {1} total - code {2}", this.SessionId, this.eventList.Count, eventData.Code);
}
}
this.resetEvent.Set();
});
}
else
{
throw new InvalidOperationException();
}
break;
}
case RtsMessageType.OperationResponse:
{
OperationResponse operationResponse;
if (this.Protocol.TryParseOperationResponse(data, out operationResponse))
{
this.fiber.Enqueue(
() =>
{
lock (this.syncRootResponse)
{
this.responseList.Add(operationResponse);
if (log.IsDebugEnabled)
{
log.DebugFormat(
"{0} receives response, {1} total - code {2}",
this.SessionId,
this.responseList.Count,
operationResponse.OperationCode);
}
}
this.resetResponse.Set();
});
}
else
{
throw new InvalidOperationException();
}
break;
}
}
return SendResults.SentOk;
}
/*
public SQLMessageInputPort(string connectionString, string tableName, string queueId, MessageContentType contentType)
{
_tableName = tableName;
_queueId = queueId;
_connStr = connectionString;
_queueName = string.Format("sql://{0}/{1}", _tableName, _queueId);
_serializationType = contentType;
}
*/
public SQLMessageInputPort(string queueName, MessageContentType contentType)
{
if (!SQLQueueProcessor.ParseQueueName(queueName, out _queueDb, out _tableName, out _queueId))
throw new Exception("Invalid queue name: " + queueName);
_queueName = queueName;
_serializationType = contentType;
//_connStr = Atmo.AtmoConfig.GetString(string.Format("Atmo.MessageBus.SQL.{0}.ConnectionString", _queueDb), "");
}
