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); }