internal void processMsg(object sender, MsgHandlerEventArgs args) { bool isClosed = false; AsyncSubscription sub = null; Msg raw = null; MsgProto mp = new MsgProto(); ProtocolSerializer.unmarshal(args.Message.Data, mp); raw = args.Message; lock (mu) { isClosed = (nc == null); subMap.TryGetValue(raw.Subject, out sub); } if (isClosed || sub == null) { return; } StanMsg msg = new StanMsg(mp, sub); sub.processMsg(mp); }
internal void manualAck(StanMsg m) { if (m == null) { return; } rwLock.EnterReadLock(); string localAckSubject = ackInbox; bool localManualAck = options.manualAcks; Connection sc = this.sc; rwLock.ExitReadLock(); if (localManualAck == false) { throw new StanManualAckException(); } if (sc == null) { throw new StanBadSubscriptionException(); } byte[] b = ProtocolSerializer.createAck(m.proto); sc.NATSConnection.Publish(localAckSubject, b); }
/// <summary> /// Constructor for generating a StanMsgHandlerArgs object. Used for application unit testing. /// </summary> /// <param name="m">A NATS streaming message.</param> public StanMsgHandlerArgs(StanMsg m) { msg = m; }
/// <summary> /// Constructor for generating a StanMsgHandlerArgs object. Used for application unit testing. /// </summary> /// <remarks> /// Objects of this type are normally generated internally by the NATS streaming client. /// This constructor has been provided to facilitate application unit testing. /// </remarks> /// <param name="data">The message payload.</param> /// <param name="redelivered">True if the message may have been redelivered.</param> /// <param name="subject">Subject of the message.</param> /// <param name="timestamp">Message timestamp, nanoseconds since epoch.(1/1/1970)</param> /// <param name="sequence">Sequence number of the message.</param> /// <param name="subscription">Subscription of the message. Must be a valid streaming subscription or null.</param> public StanMsgHandlerArgs(byte[] data, bool redelivered, string subject, long timestamp, ulong sequence, IStanSubscription subscription) { msg = new StanMsg(data, redelivered, subject, timestamp, sequence, subscription); }
/// <summary> /// Converts a base <see cref="StanMsg"/> into a <see cref="StanMsgHandlerArgs{TMessage}"/> /// for the message. /// </summary> /// <typeparam name="TMessage">The message type.</typeparam> /// <param name="message">The base message.</param> /// <returns>The new <see cref="StanMsg{TMessage}"/></returns> private static StanMsgHandlerArgs <TMessage> ToHandler <TMessage>(this StanMsg message) where TMessage : class, IRoundtripData, new() { return(new StanMsgHandlerArgs <TMessage>(message.GetProto(), message.GetSubscription())); }
/// <summary> /// Returns the <c>private</c> <see cref="AsyncSubscription "/> from a <see cref="StanMsg"/>. /// </summary> /// <param name="message">The message.</param> /// <returns>The <see cref="AsyncSubscription "/>.</returns> /// <remarks> /// <note> /// We need to return the <c>STAN.Client.AsyncScription</c> as the <see cref="object"/> /// type because it it defined as internal (grrrr....). /// </note> /// </remarks> internal static object GetSubscription(this StanMsg message) { return(stanMsgSubscriptionField.GetValue(message)); }
//--------------------------------------------------------------------- // StanMsg extensions /// <summary> /// Returns the <c>internal</c> <see cref="MsgProto"/> from a <see cref="StanMsg"/>. /// </summary> /// <param name="message">The message.</param> /// <returns>The <see cref="MsgProto"/>.</returns> internal static MsgProto GetProto(this StanMsg message) { return((MsgProto)stanMsgProtoField.GetValue(message)); }
internal StanMsgHandlerArgs(StanMsg m) { msg = m; }
/// <summary> /// Uses reflection to call the <c>internal IAsyncSubscription.manualAck(StanMsg)</c> method. /// </summary> /// <param name="subscription">The subscription.</param> /// <param name="msg">The message being acknowledged.</param> internal static void ManualAck(this object subscription, StanMsg msg) { subscriptionManualAckMethod.Invoke(subscription, new object[] { msg }); }