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