public void Send(MessageContainer message)
{
if (string.IsNullOrEmpty(message.BodyStr))
throw new Exception("Message BodyStr empty");
throw new NotImplementedException();
Message ms;
ms.AcknowledgeType = AcknowledgeTypes.PositiveReceive;
}
public void Add(int key, MessageContainer msc)
{
if (!memory.ContainsKey(key))
{
memory.Add(key, new List<MessageContainer>());
}
if (!memory[key].Contains(msc))
memory[key].Add(msc);
}
//very messy
internal void MaybeSendUnknownMethodError(MessageContainer method_call)
{
Message msg = MessageHelper.CreateUnknownMethodError(method_call);
if (msg != null)
{
Send(msg);
}
}
public void LogWarning(string text, int code, MessageOrigin origin, string subcategory = MessageSubCategory.None)
{
MessageContainer?warning = MessageContainer.CreateWarningMessage(this, text, code, origin, subcategory);
if (warning.HasValue)
{
Writer.WriteLine(warning.Value.ToMSBuildString());
}
}
public void SetUp() => Schedule(() =>
{
Child = messageContainer = new MessageContainer
{
Width = 300,
Anchor = Anchor.Centre,
Origin = Anchor.Centre
};
});
private void EnqueuePong(TPlayer player, MessageContainer message)
{
var executor = new Executor <
PongRequestExecutor <TPlayer>,
ServerModel <TPlayer>,
PongRequestMessage
>(new ServerModel <TPlayer>(this.server, player), message);
this.Execute(executor);
}
/// <summary>
/// Broadcast changes to peers
/// </summary>
/// <param name="blockToSend">The data block that should be sent to peers</param>
public async Task BroadcastNewBlockAsync(Block blockToSend)
{
var blockJson = JsonConvert.SerializeObject(blockToSend);
var container = new MessageContainer
{
MessageType = MessageType.NewBlockMined,
JsonPayload = blockJson
};
await _transportManager.SendToAllPeersAsyncTCP(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(container)));
}
public static void UpdateElems(MessageContainer messageContainer)
{
foreach (var keyValuePair in _translations)
{
var text = messageContainer != null
? messageContainer[keyValuePair.Value.LangKey] ?? keyValuePair.Value.DefaultText
: keyValuePair.Value.DefaultText;
keyValuePair.Value.TextPropertyInfo.SetValue(keyValuePair.Key, text);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="recipientMessageProcessorName">Name of message processor to forward to.</param>
/// <param name="messageToForward">Message to forward.</param>
public ForwardToMessageProcessorMessage(string recipientMessageProcessorName, MessageContainer <TMessage> messageToForward)
{
if (string.IsNullOrWhiteSpace(recipientMessageProcessorName))
{
throw new System.ArgumentException("Invalid recipient message processor name is provided.", nameof(recipientMessageProcessorName));
}
RecipientMessageProcessorName = recipientMessageProcessorName;
MessageToForward = messageToForward ?? throw new System.ArgumentNullException(nameof(messageToForward));
}
protected void Page_Init(object sender, EventArgs e)
{
ltTitre.Text = Text;
if (MessageTemplate != null)
{
var i = new MessageContainer();
MessageTemplate.InstantiateIn(i);
PlaceHolder1.Controls.Add(i);
}
}
public static MessageContainer GetContainer(string identifier, object payload)
{
var container = new MessageContainer
{
Identifier = identifier,
Payload = payload
};
return(container);
}
protected override Task ProcessMessageAsync(MessageContainer <StreamData> receivedMessage, CancellationToken cancellationToken)
{
StreamData data = receivedMessage;
return(Task.Run(() =>
{
_learner.Learn(data.FeatureVector, data.Label);
}
));
}
public MessageContainer GetContainer()
{
var container = new MessageContainer
{
Identifier = nameof(LeaveGroupRequest),
Payload = this
};
return(container);
}
public void GoDashboradPage()
{
PageFactory.InitElements(Initialize.Driver, this);
if (MessageContainer.IsDisplayed("Message Container"))
{
dialogButton.ClickOnIt("Dialog Button");
}
PageFactory.InitElements(Initialize.Driver, this);
GoDashboradButton.ClickOnIt("Go Dashborad Button");
}
public void LogWarning(string text, int code, TypeSystemEntity origin, string subcategory = MessageSubCategory.None)
{
MessageOrigin messageOrigin = new MessageOrigin(origin);
MessageContainer?warning = MessageContainer.CreateWarningMessage(this, text, code, messageOrigin, subcategory);
if (warning.HasValue)
{
Writer.WriteLine(warning.Value.ToMSBuildString());
}
}
private void CommonMessage(MessageContainer container)
{
if (((JObject)container.Payload).ToObject(typeof(CommonChatMsgResponse)) is CommonChatMsgResponse msgRequest)
{
var mess = new MessageReceivedEventArgs(new TextMsgRequest(msgRequest.From, "CommonChat", msgRequest.Message, MsgStatus.None));
MessageReceived?.Invoke(this, mess);
var mgContainer = new ClientOkMsgResponse(msgRequest.From, "CommonChat", msgRequest.Date);
Send(mgContainer);
}
}
public static MessageContainer MakeMessage(Message message, bool isContinuation = false, bool lastread = false)
{
MessageContainer msg = new MessageContainer(message, GetMessageType(message.Type), isContinuation, null, false);
if (lastread)
{
msg.LastRead = true;
}
return(msg);
}
public void SendAll(Guid clientGuid, MessageContainer message)
{
foreach (var connection in _connections)
{
if (connection.Key != clientGuid)
{
connection.Value.Send(message);
}
}
}
public MessageContainer GetContainer()
{
var container = new MessageContainer
{
Identifier = nameof(ConnectionRequest),
Payload = this
};
return(container);
}
private void EnqueuePingResult(MessageContainer message)
{
var executor = new Executor <
PingResultRequestExecutor <TPlayer>,
GameClient <TPlayer>,
PingResultRequestMessage
>(this.game, message);
this.Execute(executor);
}
public void AddRangeTest()
{
var list = new MessageContainer <int>(10);//限量10条
for (int i = 0; i < 1000; i++)
{
list.AddRange(new[] { i, i + 1, i + 2 });
}
Assert.AreEqual(10, list.Count);
}
public static MessageContainer MakeMessage(string chnId, Discord_UWP.API.Channel.Models.MessageUpsert upsert)
{
Message message = new Message()
{
ChannelId = chnId, Content = upsert.Content, User = LocalState.CurrentUser, TTS = upsert.TTS, Timestamp = DateTime.Now
};
MessageContainer msg = new MessageContainer(message, GetMessageType(message.Type), false, null, true);
return(msg);
}
private void ClientRegistration(MessageContainer container)
{
if (((JObject)container.Payload).ToObject(typeof(ConnectionResponse)) is ConnectionResponse connectionResponse &&
connectionResponse.Result == ResultCodes.Failure)
{
return;
}
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(true));
}
public override void OnEnter()
{
MessageContainer mWindow = UIUtility.Find <MessageContainer> (_name.Value);
if (mWindow != null)
{
mWindow.Remove(message.Value);
}
Finish();
}
public void AddRangeTest()
{
var list = new MessageContainer<int>(10);//限量10条
for (int i = 0; i < 1000; i++)
{
list.AddRange(new[] { i, i + 1, i + 2 });
}
Assert.AreEqual(10, list.Count);
}
public static MessageContainer GetContainer(string identifier, object valueForContainer)
{
var container = new MessageContainer
{
Identifier = identifier,
Payload = valueForContainer
};
return(container);
}
private void EnqueueDisconnectedPlayer(MessageContainer message)
{
var executor = new Executor <
DisconnectedPlayerExecutor,
IRemoteClientListener,
DisconnectedPlayerMessage
>(this.game, message);
this.Execute(executor);
}
private void SendMessage(MessageContainer msgContainer, string targetId)
{
foreach (KeyValuePair <string, WsConnection> connection in _connections)
{
if (connection.Key == targetId)
{
connection.Value.Send(msgContainer);
}
}
}
public pullSnapshotDataResponse pullSnapshotData(pullSnapshotDataRequest request)
{
DataManager dataManager = new DataManager();
pullSnapshotDataResponse response = null;
MessageContainer msg = dataManager.GetData();
if (msg != null)
{
response = new pullSnapshotDataResponse();
msg.exchangeInformation.exchangeContext.supplierOrCisRequester.internationalIdentifier.nationalIdentifier = "DEMO";
msg.exchangeInformation.exchangeContext.supplierOrCisRequester.internationalIdentifier.country = "SE";
msg.exchangeInformation.dynamicInformation.messageGenerationTimestamp = DateTime.UtcNow;
response.pullSnapshotDataOutput = msg;
}
else
{
#region Return fail message
response = new pullSnapshotDataResponse();
response.pullSnapshotDataOutput = new MessageContainer();
response.pullSnapshotDataOutput.modelBaseVersion = "3";
ExchangeInformation exchangeInfo = new ExchangeInformation();
ExchangeContext exchangeContext = new ExchangeContext();
exchangeContext.codedExchangeProtocol = new _ProtocolTypeEnum()
{
Value = ProtocolTypeEnum.snapshotPull
};
exchangeContext.exchangeSpecificationVersion = "3";
Agent agent = new Agent();
InternationalIdentifier identifier = new InternationalIdentifier {
nationalIdentifier = "DEMO", country = "SE"
};
agent.internationalIdentifier = identifier;
exchangeContext.supplierOrCisRequester = agent;
exchangeInfo.exchangeContext = exchangeContext;
DynamicInformation dynamicInformation = new DynamicInformation();
_ExchangeStatusEnum exchangeStatusEnum = new _ExchangeStatusEnum {
Value = ExchangeStatusEnum.undefined
};
dynamicInformation.messageGenerationTimestamp = DateTime.UtcNow;
dynamicInformation.exchangeStatus = exchangeStatusEnum;
exchangeInfo.dynamicInformation = dynamicInformation;
dynamicInformation.returnInformation = new ReturnInformation();
dynamicInformation.returnInformation.returnStatus = new _ExchangeReturnEnum();
dynamicInformation.returnInformation.returnStatus.Value = ExchangeReturnEnum.fail;
#endregion
}
return(response);
}
public async Task ConcurrencyTest2() //TODO Not a fair comparison
{
var messages = MessageGenerator.GenerateMessages(200);
var headers = MessageGenerator.GenerateMessageHeaders(messages, "Topic1", 1);
var stopWatch = new Stopwatch();
var container = new MessageContainer[headers.Length];
var semaphore = new Semaphore(1, 1);
for (var i = 0; i < headers.Length; i++)
{
container[i] = new MessageContainer
{
Header = headers[i],
Messages = messages.ToList()
};
}
var data = new byte[headers.Length][];
for (int i = 0; i < container.Length; i++)
{
data[i] = LZ4MessagePackSerializer.Serialize(container[i]);
}
var tasks = new Task[data.Length];
var sockets = new BrokerSocket[data.Length];
for (int i = 0; i < data.Length; i++)
{
var i1 = i;
sockets[i] = new BrokerSocket();
tasks[i] = new Task(async() =>
{
await sockets[i1].SendMessage(data[i1]);
});
}
stopWatch.Start();
for (int i = 0; i < data.Length; i++)
{
await sockets[i].ConnectToBroker("ws://localhost:5000/ws");
tasks[i].Start();
}
stopWatch.Stop();
await Task.Delay(2 * 1000);
for (int i = 0; i < data.Length; i++)
{
await sockets[i].DeleteConnection();
}
_testOutputHelper.WriteLine($"Time: {stopWatch.ElapsedTicks}");
}
private Task OnRemoteUpdate(MessageContainer obj)
{
var message = MessageUpdateOrigin.Unpack(obj);
targetLocalPosition = message.Position;
targetLocalRotation = message.Orientation;
targetLocalScale = new Vector3(message.Scale, message.Scale, message.Scale);
changedFromNetwork = true;
return(Task.CompletedTask);
}
void MarkProperty(TypeDefinition type, PropertyDefinition property, string[] accessors, bool required)
{
if (Annotations.IsMarked(property))
{
Context.LogMessage(MessageContainer.CreateWarningMessage($"Duplicate preserve of '{property.FullName}' in '{_xmlDocumentLocation}'", 2025));
}
Annotations.Mark(property, new DependencyInfo(DependencyKind.XmlDescriptor, _xmlDocumentLocation));
MarkPropertyAccessors(type, property, accessors, required);
}
public void InsertTest()
{
var list = new MessageContainer<int>(10);//限量10条
for (int i = 0; i < 1000; i++)
{
list.Insert(0, i);
}
Assert.AreEqual(10, list.Count);
Assert.AreEqual(9, list[0]);
}
public void InsertTest()
{
var list = new MessageContainer <int>(10);//限量10条
for (int i = 0; i < 1000; i++)
{
list.Insert(0, i);
}
Assert.AreEqual(10, list.Count);
Assert.AreEqual(9, list[0]);
}
public static Terms.Base.Domain.ErrorMessage GetMessage(MessageContainer code, IList list)
{
Terms.Base.Domain.ErrorMessage msgFinded;
//如果错误信息为空，返回空
if(code.MessageCode == string.Empty)
{
return null;
}
//初始化
msgFinded = null;
////对内部错误进行遍历
//while (code.InnerMessage != null)
//{
//}
//取得最外层的数据信息
foreach (Terms.Base.Domain.ErrorMessage msg in list)
{
if (msg.Code == code.MessageCode)
{
//将错误信息补全
if (code.Parameters != null)
{
msg.Text = string.Format(msg.Text, code.Parameters);
msgFinded = msg;
}
else
{
msgFinded = msg;
}
break;
}
}
//如果存在内部错误信息，则取得内部错误信息
if (code.InnerMessage != null)
{
msgFinded.InnerMessage = GetMessage(code.InnerMessage, list);
}
return msgFinded;
}
/// <summary>
/// Transfers registered messages to the message container.
/// </summary>
/// <param name="messageContainer">The Message Containter.</param>
public void MoveMessages(MessageContainer messageContainer)
{
lock (this)
{
for ( int i = 0; i < this._messages.Length; i++ )
{
Message message = this._messages[i] as Message;
// 2.5.1 ignores messages that have been answered
if (message != null && ! message.HasBeenAsnwered)
{
message.SerializedContent.Position = 0;
messageContainer.AddMessage(message, false);
this._messages[i] = null;
}
}
}
}
public List<byte[]> GetOrphanedBinaryRequest(MessageContainer reference)
{
var msg = new List<byte[]>()
{
"servicea".HexStrToByteArray(),
MDP.M_EMPTY,
MDP.W_WORKER_B,
new byte[]{0x02},
"0x00A56BB175828140B186DC95EC881BBA8F".HexStrToByteArray(),
MDP.M_EMPTY,
"0x123123".ToBytes(),
"toservicea".ToBytes(),
MDP.M_EMPTY,
new byte[] {0x0, 0x1, 0x2}
};
return msg;
}
public void InsertRangeTest()
{
var list = new MessageContainer<int>(10);//限量10条
for (int i = 0; i < 1000; i++)
{
list.InsertRange(0, new[] { i, i + 1, i + 2 });
//i=0:0,1,2
//i=1:1,2,3,0,1,2
//i=2:2,3,4,1,2,3,0,1,2
//i=3:3,4,5,2,3,4,1,2,3,0,1,2 -> 5,2,3,4,1,2,3,0,1,2
}
Assert.AreEqual(10, list.Count);
Assert.AreEqual(5, list[0]);
Assert.AreEqual(2, list[1]);
Assert.AreEqual(3, list[2]);
Assert.AreEqual(4, list[3]);
}
//class' constructor
public Console(int width = 320, int height = 200, Vector2 position = default(Vector2))
{
this.consoleMessage = new MessageType(tag: "[Console]");
this.msgContainer = new MessageContainer(numberOfMessages: maxMessages);
this.width = width;
this.height = height;
this.position = position;
updateRect();
this.isVisible = false;
this.scrollPosition = new Vector2(x: 0.0f, y: maxMessages*25.0f);
this.userCommand = "";
commands = new Queue<Command>();
setupCustomStyles();
Input.eatKeyPressOnTextFieldFocus = false;
writeLine(msg: "Initialized successfully!", messageType: consoleMessage, priority: 0);
}
public void AddTest()
{
var list = new MessageContainer<int>(-1);
//测试不限量添加
for (int i = 0; i < 1000; i++)
{
list.Add(i);
}
Assert.AreEqual(1000, list.Count);
//限量
list.MaxRecordCount = 100;//限量100条
for (int i = 0; i < 1000; i++)
{
list.Add(i);
}
Assert.AreEqual(100, list.Count);
}
public void Sleep() {
MessageContainer mc = new MessageContainer(MessageContainer.MessageType.Sleep);
MessageQueue.GetInstance().AddMessage(mc);
}
/// <summary>
/// Fills in the provided stream with the specified messages that the total size as close to the recommended size as possible.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageContainer">Accumulated messages or a null reference.</param>
/// <param name="packedMessages">This instance will contain all packed messages after this function completes.</param>
/// <param name="resultContent">The filled stream.</param>
/// <param name="intermediateBuffer">The intermediate buffer.</param>
/// <param name="recommendedSize">The recommended size.</param>
public static void FillInLabelledStream(Message message, MessageContainer messageContainer, ArrayList packedMessages, GenuineChunkedStream resultContent, byte[] intermediateBuffer, int recommendedSize)
{
BinaryWriter binaryWriter = new BinaryWriter(resultContent);
if (packedMessages != null)
packedMessages.Clear();
while ( message != null )
{
// not finished yet
binaryWriter.Write((byte) 0);
if (packedMessages != null)
packedMessages.Add(message);
MessageCoder.WriteLabelledStream(message.SerializedContent, resultContent, binaryWriter, intermediateBuffer);
message = null;
if (resultContent.Length > recommendedSize)
break;
if (messageContainer != null)
message = messageContainer.GetMessage();
if (message == null)
break;
}
// "finish" flag
binaryWriter.Write((byte) 1);
}
public static Message CreateUnknownMethodError(MessageContainer method_call)
{
Message msg = method_call.Message;
if (!msg.ReplyExpected)
return null;
string errMsg = String.Format ("Method \"{0}\" with signature \"{1}\" on interface \"{2}\" doesn't exist",
method_call.Member,
method_call.Signature.Value,
method_call.Interface);
var error = new MessageContainer {
ErrorName = "org.freedesktop.DBus.Error.UnknownMethod",
Serial = msg.Header.Serial,
Signature = Signature.StringSig,
};
MessageWriter writer = new MessageWriter (Connection.NativeEndianness);
writer.Write (errMsg);
msg = error.Message;
msg.AttachBodyTo (writer);
//TODO: we should be more strict here, but this fallback was added as a quick fix for p2p
if (method_call.Sender != null)
msg.Header[FieldCode.Destination] = method_call.Sender;
return msg;
}
protected void Page_Load(object sender, EventArgs e)
{
switch (myAlertType)
{
case AlertType.Normal:
alertbar.ClientIDMode = ClientIDMode.Static;
alert.ClientIDMode = ClientIDMode.Static;
break;
case AlertType.Small:
alertbar.ClientIDMode = ClientIDMode.Inherit;
alert.ClientIDMode = ClientIDMode.Inherit;
break;
case AlertType.Mini:
alertbar.ClientIDMode = ClientIDMode.Inherit;
alert.ClientIDMode = ClientIDMode.Inherit;
break;
default:
break;
}
if (messageTemplate != null)
{
MessageContainer container;
if (!String.IsNullOrWhiteSpace(staticText))
container = new MessageContainer(staticText);
else
//if (pharmacyName == "")
//{
// container = new MessageContainer(saveTotal, navigateTo);
//}
//else
//{
container = new MessageContainer(saveTotal, navigateTo, pharmacyName, CouldVisible, MaxVisible);
//}
messageTemplate.InstantiateIn(container);
AlertPlaceHolder.Controls.Add(container);
}
DataBind();
}
public virtual void HandleMethodCall(MessageContainer method_call)
{
MethodInfo mi;
if (!methodInfoCache.TryGetValue(method_call.Member, out mi))
methodInfoCache[method_call.Member] = mi = Mapper.GetMethod(Object.GetType(), method_call);
if (mi == null)
{
conn.MaybeSendUnknownMethodError(method_call);
return;
}
MethodCaller mCaller;
if (!mCallers.TryGetValue(mi, out mCaller))
{
mCaller = TypeImplementer.GenCaller(mi);
mCallers[mi] = mCaller;
}
Signature inSig, outSig;
TypeImplementer.SigsForMethod(mi, out inSig, out outSig);
Message msg = method_call.Message;
MessageReader msgReader = new MessageReader(msg);
MessageWriter retWriter = new MessageWriter();
Exception raisedException = null;
try
{
mCaller(Object, msgReader, msg, retWriter);
}
catch (Exception e)
{
raisedException = e;
}
if (!msg.ReplyExpected)
return;
Message replyMsg;
if (raisedException == null)
{
MessageContainer method_return = new MessageContainer
{
Type = MessageType.MethodReturn,
ReplySerial = msg.Header.Serial
};
replyMsg = method_return.Message;
replyMsg.AttachBodyTo(retWriter);
replyMsg.Signature = outSig;
}
else
{
// BusException allows precisely formatted Error messages.
BusException busException = raisedException as BusException;
if (busException != null)
replyMsg = method_call.CreateError(busException.ErrorName, busException.ErrorMessage);
else if (raisedException is ArgumentException && raisedException.TargetSite.Name == mi.Name)
{
// Name match trick above is a hack since we don't have the resolved MethodInfo.
ArgumentException argException = (ArgumentException)raisedException;
using (System.IO.StringReader sr = new System.IO.StringReader(argException.Message))
{
replyMsg = method_call.CreateError("org.freedesktop.DBus.Error.InvalidArgs", sr.ReadLine());
}
}
else
replyMsg = method_call.CreateError(Mapper.GetInterfaceName(raisedException.GetType()), raisedException.Message);
}
if (method_call.Sender != null)
replyMsg.Header[FieldCode.Destination] = method_call.Sender;
conn.Send(replyMsg);
}
public bool Delete(MessageContainer message)
{
return false;
}
//this method walks the interface tree in an undefined manner and returns the first match, or if no matches are found, null
//the logic needs review and cleanup
//TODO: unify member name mapping as is already done with interfaces and args
public static MethodInfo GetMethod(Type type, MessageContainer method_call)
{
var mems = Mapper.GetPublicMembers (type).ToArray ();
foreach (var memberForType in mems) {
//this could be made more efficient by using the given interface name earlier and avoiding walking through all public interfaces
if (method_call.Interface != null)
if (GetInterfaceName (memberForType.Key) != method_call.Interface)
continue;
MemberInfo member = memberForType.Value;
MethodInfo meth = null;
Type[] inTypes = null;
if (member is PropertyInfo) {
PropertyInfo prop = member as PropertyInfo;
MethodInfo getter = prop.GetGetMethod (false);
MethodInfo setter = prop.GetSetMethod (false);
if (getter != null && "Get" + prop.Name == method_call.Member) {
meth = getter;
inTypes = Type.EmptyTypes;
} else if (setter != null && "Set" + prop.Name == method_call.Member) {
meth = setter;
inTypes = new Type[] {prop.PropertyType};
}
} else {
meth = member as MethodInfo;
if (meth == null)
continue;
if (meth.Name != method_call.Member)
continue;
inTypes = Mapper.GetTypes (ArgDirection.In, meth.GetParameters ());
}
if (meth == null || inTypes == null)
continue;
Signature inSig = Signature.GetSig (inTypes);
if (inSig != method_call.Signature)
continue;
return meth;
}
return null;
}
/// <summary>
/// Adds a MessageContainer Object to the Queue
/// </summary>
/// <param name="messageContainer">the MessageContainer</param>
public void AddMessage(MessageContainer messageContainer) {
lock (this) {
queue.Enqueue(messageContainer);
semaphore.Release();
}
}
public void AbortAll() {
MessageContainer mc = new MessageContainer(MessageContainer.MessageType.AbortAll);
MessageQueue.GetInstance().AddMessage(mc);
}
/// <summary>
/// Send container over to the other side.
/// </summary>
/// <param name="messageContainer"></param>
/// <returns></returns>
public virtual bool SendMessageContainer(MessageContainer messageContainer)
{
TracerHelper.TraceEntry("sending [" + messageContainer.MessageStreamLength + "], sessionID[" + this.ConnectionSessionID + "]");
SystemMonitor.CheckThrow(messageContainer.MessageStreamLength <= MessageContainerTransportServer.MaximumAllowedMessageSize, "MessageContainer message is too big. Message will not be sent.");
if (_connectingEvent.WaitOne(_defaultConnectionTimeOut) == false)
{
SystemMonitor.OperationError("Failed to send message due to initialization timeout.", TracerItem.PriorityEnum.Medium);
return false;
}
try
{
IMessageContainerTransport messageInterface;
lock (this)
{
if (_proxyServerInterface == null)
{
TracerHelper.TraceError("Failed to send to server, interface not created.");
return false;
}
messageInterface = _proxyServerInterface;
}
messageInterface.ReceiveMessageContainer(messageContainer);
lock (this)
{
_lastServerCall = DateTime.Now;
}
}
catch (Exception exception)
{
TracerHelper.TraceError("Failed to send to server, reason [" + exception.Message + "].");
return false;
}
return true;
}
/// <summary>
/// Receive container from the server.
/// </summary>
/// <param name="messageContainer"></param>
public virtual void ReceiveMessageContainer(MessageContainer messageContainer)
{
//_connectionSessionID = OperationContext.Current.SessionId;
if (MessageContainerReceivedEvent != null)
{
TracerHelper.Trace("receiving [" + messageContainer.MessageStreamLength + "], sessionID[" + this.ConnectionSessionID + "]");
MessageContainerReceivedEvent(messageContainer);
}
else
{
SystemMonitor.OperationError("container missed [" + messageContainer.MessageStreamLength + "], sessionID[" + this.ConnectionSessionID + "]");
}
lock (this)
{
_lastServerCall = DateTime.Now;
}
}
public void SendSignal(string iface, string member, string inSigStr, MessageWriter writer, Type retType, out Exception exception)
{
exception = null;
Signature outSig = String.IsNullOrEmpty (inSigStr) ? Signature.Empty : new Signature (inSigStr);
MessageContainer signal = new MessageContainer {
Type = MessageType.Signal,
Path = object_path,
Interface = iface,
Member = member,
Signature = outSig,
};
Message signalMsg = signal.Message;
signalMsg.AttachBodyTo (writer);
conn.Send (signalMsg);
}
public MessageReader SendMethodCall(string iface, string member, string inSigStr, MessageWriter writer, Type retType, out Exception exception)
{
if (string.IsNullOrEmpty (bus_name))
throw new ArgumentNullException ("bus_name");
if (object_path == null)
throw new ArgumentNullException ("object_path");
exception = null;
Signature inSig = String.IsNullOrEmpty (inSigStr) ? Signature.Empty : new Signature (inSigStr);
MessageContainer method_call = new MessageContainer {
Path = object_path,
Interface = iface,
Member = member,
Destination = bus_name,
Signature = inSig
};
Message callMsg = method_call.Message;
callMsg.AttachBodyTo (writer);
bool needsReply = true;
callMsg.ReplyExpected = needsReply;
callMsg.Signature = inSig;
if (!needsReply) {
conn.Send (callMsg);
return null;
}
#if PROTO_REPLY_SIGNATURE
if (needsReply) {
Signature outSig = Signature.GetSig (retType);
callMsg.Header[FieldCode.ReplySignature] = outSig;
}
#endif
Message retMsg = conn.SendWithReplyAndBlock (callMsg);
MessageReader retVal = null;
//handle the reply message
switch (retMsg.Header.MessageType) {
case MessageType.MethodReturn:
retVal = new MessageReader (retMsg);
break;
case MessageType.Error:
MessageContainer error = MessageContainer.FromMessage (retMsg);
string errMsg = String.Empty;
if (retMsg.Signature.Value.StartsWith ("s")) {
MessageReader reader = new MessageReader (retMsg);
errMsg = reader.ReadString ();
}
exception = new Exception (error.ErrorName + ": " + errMsg);
break;
default:
throw new Exception ("Got unexpected message of type " + retMsg.Header.MessageType + " while waiting for a MethodReturn or Error");
}
return retVal;
}
/// <summary>
/// Adds a message to the Queue. The MessageContainer Object is built in the Method
/// </summary>
/// <param name="message">the Message</param>
public void AddMessage(MessageContainer.MessageType message) {
lock (this) {
queue.Enqueue(new MessageContainer(message));
semaphore.Release();
}
}
public static Message ConstructDynamicReply(MessageContainer method_call, MethodInfo mi, object retVal, object[] vals)
{
Type retType = mi.ReturnType;
MessageContainer method_return = new MessageContainer {
Serial = method_call.Serial,
};
Message replyMsg = method_return.Message;
Signature outSig = Signature.GetSig (retType);
outSig += Signature.GetSig (Mapper.GetTypes (ArgDirection.Out, mi.GetParameters ()));
if (outSig != Signature.Empty) {
MessageWriter writer = new MessageWriter (Connection.NativeEndianness);
//first write the return value, if any
if (retType != null && retType != typeof (void))
writer.Write (retType, retVal);
//then write the out args
WriteDynamicValues (writer, mi.GetParameters (), vals);
replyMsg.AttachBodyTo (writer);
}
//TODO: we should be more strict here, but this fallback was added as a quick fix for p2p
if (method_call.Sender != null)
replyMsg.Header[FieldCode.Destination] = method_call.Sender;
replyMsg.Signature = outSig;
return replyMsg;
}
public void Restart() {
MessageContainer mc = new MessageContainer(MessageContainer.MessageType.Restart);
MessageQueue.GetInstance().AddMessage(mc);
}
public bool Undo(MessageContainer message)
{
return MessageCache.Undo(message);
}
public static Message ConstructReply(MessageContainer method_call, params object[] vals)
{
var msg = method_call.Message;
MessageContainer method_return = new MessageContainer {
Type = MessageType.MethodReturn,
ReplySerial = msg.Header.Serial
};
Message replyMsg = method_return.Message;
Signature inSig = Signature.GetSig (vals);
if (vals != null && vals.Length != 0) {
MessageWriter writer = new MessageWriter (Connection.NativeEndianness);
foreach (object arg in vals)
writer.Write (arg.GetType (), arg);
replyMsg.AttachBodyTo (writer);
}
//TODO: we should be more strict here, but this fallback was added as a quick fix for p2p
if (method_call.Sender != null)
replyMsg.Header[FieldCode.Destination] = method_call.Sender;
replyMsg.Signature = inSig;
//replyMsg.WriteHeader ();
return replyMsg;
}
/// <summary>
///
/// </summary>
/// <param name="maxRecordCount">maxRecordCount如果小于等于0，则不限制</param>
public MessageContext()
{
/*
* 注意：即使使用其他类实现IMessageContext，
* 也务必在这里进行下面的初始化，尤其是设置当前时间，
* 这个时间关系到及时从缓存中移除过期的消息，节约内存使用
*/
RequestMessages = new MessageContainer<IRequestMessageBase>(MaxRecordCount);
ResponseMessages = new MessageContainer<IResponseMessageBase>(MaxRecordCount);
LastActiveTime = DateTime.Now;
}
public static Message CreateUnknownMethodError(MessageContainer method_call)
{
Message msg = method_call.Message;
if (!msg.ReplyExpected)
return null;
string errMsg = String.Format ("Method \"{0}\" with signature \"{1}\" on interface \"{2}\" doesn't exist",
method_call.Member,
method_call.Signature.Value,
method_call.Interface);
return method_call.CreateError ("org.freedesktop.DBus.Error.UnknownMethod", errMsg);
}
