public static void ProcessSingleDelivery(BasicDeliverEventArgs e) { Console.WriteLine("Delivery ========================================="); DebugUtil.DumpProperties(e, Console.Out, 0); Console.WriteLine("----------------------------------------"); if (e.BasicProperties.ContentType == MapMessageReader.MimeType) { IMapMessageReader r = new MapMessageReader(e.BasicProperties, e.Body); DebugUtil.DumpProperties(r.Body, Console.Out, 0); } else if (e.BasicProperties.ContentType == StreamMessageReader.MimeType) { IStreamMessageReader r = new StreamMessageReader(e.BasicProperties, e.Body); while (true) { try { object v = r.ReadObject(); Console.WriteLine("(" + v.GetType() + ") " + v); } catch (EndOfStreamException) { break; } } } else { // No special content-type. Already covered by the DumpProperties above. } Console.WriteLine("=================================================="); }
///<summary>Sends a "jms/stream-message"-encoded RPC request, ///and expects an RPC reply in the same format.</summary> ///<remarks> ///<para> /// The arguments passed in must be of types that are /// representable as JMS StreamMessage values, and so must the /// results returned from the service in its reply message. ///</para> ///<para> /// Calls OnTimedOut() and OnDisconnected() when a timeout or /// disconnection, respectively, is detected when waiting for /// our reply. ///</para> ///<para> /// Returns null if the request timed out or if we were /// disconnected before a reply arrived. ///</para> ///<para> /// The reply message, if any, is acknowledged to the AMQP /// server via Subscription.Ack(). ///</para> ///</remarks> ///<see cref="IStreamMessageBuilder"/> ///<see cref="IStreamMessageReader"/> public virtual object[] Call(params object[] args) { IStreamMessageBuilder builder = new StreamMessageBuilder(Model); builder.WriteObjects(args); IBasicProperties replyProperties; byte[] replyBody = Call((IBasicProperties)builder.GetContentHeader(), builder.GetContentBody(), out replyProperties); if (replyProperties == null) { return(null); } if (replyProperties.ContentType != StreamMessageBuilder.MimeType) { throw new ProtocolViolationException (string.Format("Expected reply of MIME type {0}; got {1}", StreamMessageBuilder.MimeType, replyProperties.ContentType)); } IStreamMessageReader reader = new StreamMessageReader(replyProperties, replyBody); return(reader.ReadObjects()); }
///<summary>Called by ProcessRequest(), this is the most ///general method that handles asynchronous, one-way ///requests.</summary> ///<remarks> ///<para> /// The default implementation checks /// requestProperties.ContentType, and if it is /// "jms/stream-message" (i.e. the current value of /// StreamMessageBuilder.MimeType), parses it using /// StreamMessageReader and delegates to /// HandleStreamMessageCall, passing in null as the /// replyWriter parameter to indicate that no reply is desired /// or possible. If the ContentType is any other value, the /// request is passed to HandleSimpleCast instead. ///</para> ///<para> /// The isRedelivered flag is true when the server knows for /// sure that it has tried to send this request previously /// (although not necessarily to this application). It is not /// a reliable indicator of previous receipt, however - the /// only claim it makes is that a delivery attempt was made, /// not that the attempt succeeded. Be careful if you choose /// to use the isRedelivered flag. ///</para> ///</remarks> public virtual void HandleCast(bool isRedelivered, IBasicProperties requestProperties, byte[] body) { if (requestProperties.ContentType == StreamMessageBuilder.MimeType) { IStreamMessageReader r = new StreamMessageReader(requestProperties, body); HandleStreamMessageCall(null, isRedelivered, requestProperties, r.ReadObjects()); } else { HandleSimpleCast(isRedelivered, requestProperties, body); } }
///<summary>Called by ProcessRequest(), this is the most ///general method that handles RPC-style requests.</summary> ///<remarks> ///<para> /// This method should map requestProperties and body to /// replyProperties and the returned byte array. ///</para> ///<para> /// The default implementation checks /// requestProperties.ContentType, and if it is /// "jms/stream-message" (i.e. the current value of /// StreamMessageBuilder.MimeType), parses it using /// StreamMessageReader and delegates to /// HandleStreamMessageCall before encoding and returning the /// reply. If the ContentType is any other value, the request /// is passed to HandleSimpleCall instead. ///</para> ///<para> /// The isRedelivered flag is true when the server knows for /// sure that it has tried to send this request previously /// (although not necessarily to this application). It is not /// a reliable indicator of previous receipt, however - the /// only claim it makes is that a delivery attempt was made, /// not that the attempt succeeded. Be careful if you choose /// to use the isRedelivered flag. ///</para> ///</remarks> public virtual byte[] HandleCall(bool isRedelivered, IBasicProperties requestProperties, byte[] body, out IBasicProperties replyProperties) { if (requestProperties.ContentType == StreamMessageBuilder.MimeType) { IStreamMessageReader r = new StreamMessageReader(requestProperties, body); IStreamMessageBuilder w = new StreamMessageBuilder(m_subscription.Model); HandleStreamMessageCall(w, isRedelivered, requestProperties, r.ReadObjects()); replyProperties = (IBasicProperties)w.GetContentHeader(); return(w.GetContentBody()); } else { return(HandleSimpleCall(isRedelivered, requestProperties, body, out replyProperties)); } }