public virtual void start() { if (corr == null) { corr = new RequestCorrelator("MsgDisp", channel, this, deadlock_detection, channel.LocalAddress, concurrent_processing, this._ncacheLog); corr.start(); if (System.Configuration.ConfigurationSettings.AppSettings["useAvgStats"] != null) { useAvgStats = Convert.ToBoolean(System.Configuration.ConfigurationSettings.AppSettings["useAvgStats"]); } } }
public Request(RequestCorrelator enclosingInstance, Message req) { this.enclosingInstance = enclosingInstance; this.req = req; }
/// <param name="timeout">Time to wait for responses (ms). A value of <= 0 means wait indefinitely /// (e.g. if a suspicion service is available; timeouts are not needed). /// </param> public GroupRequest(Message m, RequestCorrelator corr, ArrayList members, ArrayList clusterCompleteMembership, byte rsp_mode, long timeout, int expected_mbrs, ILogger NCacheLog) : this(m, corr, members, clusterCompleteMembership, rsp_mode, NCacheLog) { if (timeout > 0) this.timeout = timeout; this.expected_mbrs = expected_mbrs; }
/// <param name="m">The message to be sent /// </param> /// <param name="corr">The request correlator to be used. A request correlator sends requests tagged with /// a unique ID and notifies the sender when matching responses are received. The /// reason <code>GroupRequest</code> uses it instead of a <code>Transport</code> is /// that multiple requests/responses might be sent/received concurrently. /// </param> /// <param name="members">The initial membership. This value reflects the membership to which the request /// is sent (and from which potential responses are expected). Is reset by reset(). /// </param> /// <param name="rsp_mode">How many responses are expected. Can be /// <ol> /// <li><code>GET_ALL</code>: wait for all responses from non-suspected members. /// A suspicion service might warn /// us when a member from which a response is outstanding has crashed, so it can /// be excluded from the responses. If no suspision service is available, a /// timeout can be used (a value of 0 means wait forever). <em>If a timeout of /// 0 is used, no suspicion service is available and a member from which we /// expect a response has crashed, this methods blocks forever !</em>. /// <li><code>GET_FIRST</code>: wait for the first available response. /// <li><code>GET_MAJORITY</code>: wait for the majority of all responses. The /// majority is re-computed when a member is suspected. /// <li><code>GET_ABS_MAJORITY</code>: wait for the majority of /// <em>all</em> members. /// This includes failed members, so it may block if no timeout is specified. /// <li><code>GET_N</CODE>: wait for N members. /// Return if n is >= membership+suspects. /// <li><code>GET_NONE</code>: don't wait for any response. Essentially send an /// asynchronous message to the group members. /// </ol> /// </param> public GroupRequest(Message m, RequestCorrelator corr, ArrayList members, ArrayList clusterCompleteMembership, byte rsp_mode, ILogger NCacheLog) { request_msg = m; this.corr = corr; this.rsp_mode = rsp_mode; this._ncacheLog = NCacheLog; this.clusterMembership = clusterCompleteMembership; reset(members); }