public static CreateSequenceInfo ReadMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, ISecureConversationSession securitySession, Message message, MessageHeaders headers)
{
CreateSequenceInfo info;
if (message.IsEmpty)
{
string reason = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion) });
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
}
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
{
info = CreateSequence.Create(messageVersion, reliableMessagingVersion, securitySession, reader);
message.ReadFromBodyContentsToEnd(reader);
}
info.SetMessageId(messageVersion, headers);
info.SetReplyTo(messageVersion, headers);
if (info.AcksTo.Uri != info.ReplyTo.Uri)
{
string str2 = System.ServiceModel.SR.GetString("CSRefusedAcksToMustEqualReplyTo");
Message message3 = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, str2);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(message3, str2, new ProtocolException(str2)));
}
info.to = message.Headers.To;
if ((info.to == null) && (messageVersion.Addressing == AddressingVersion.WSAddressing10))
{
info.to = messageVersion.Addressing.AnonymousUri;
}
return(info);
}
public static WsrmSequencedMessageInfo ReadHeader(ReliableMessagingVersion reliableMessagingVersion, XmlDictionaryReader reader, MessageHeaderInfo header)
{
WsrmFeb2005Dictionary dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString namespaceUri = WsrmIndex.GetNamespace(reliableMessagingVersion);
reader.ReadStartElement();
reader.ReadStartElement(dictionary.Identifier, namespaceUri);
UniqueId sequenceID = reader.ReadContentAsUniqueId();
reader.ReadEndElement();
reader.ReadStartElement(dictionary.MessageNumber, namespaceUri);
long sequenceNumber = WsrmUtilities.ReadSequenceNumber(reader);
reader.ReadEndElement();
bool lastMessage = false;
if ((reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005) && reader.IsStartElement(dictionary.LastMessage, namespaceUri))
{
WsrmUtilities.ReadEmptyElement(reader);
lastMessage = true;
}
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
return(new WsrmSequencedMessageInfo(sequenceID, sequenceNumber, lastMessage, header));
}
private static WsrmHeaderFault CreateWsrmHeaderFault(ReliableMessagingVersion reliableMessagingVersion, FaultCode code, string subcode, FaultReason reason, XmlDictionaryReader detailReader)
{
if (code.IsSenderFault)
{
if (subcode == "InvalidAcknowledgement")
{
return(new InvalidAcknowledgementFault(code, reason, detailReader, reliableMessagingVersion));
}
if (subcode == "MessageNumberRollover")
{
return(new MessageNumberRolloverFault(code, reason, detailReader, reliableMessagingVersion));
}
if (subcode == "UnknownSequence")
{
return(new UnknownSequenceFault(code, reason, detailReader, reliableMessagingVersion));
}
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (subcode == "LastMessageNumberExceeded")
{
return(new LastMessageNumberExceededFault(code, reason, detailReader, reliableMessagingVersion));
}
}
else if ((reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11) && (subcode == "SequenceClosed"))
{
return(new SequenceClosedFault(code, reason, detailReader, reliableMessagingVersion));
}
}
if (!code.IsSenderFault && !code.IsReceiverFault)
{
return(null);
}
return(new SequenceTerminatedFault(code, reason, detailReader, reliableMessagingVersion));
}
internal static void WriteAckRanges(XmlDictionaryWriter writer, ReliableMessagingVersion reliableMessagingVersion, UniqueId sequenceId, SequenceRangeCollection ranges)
{
WsrmFeb2005Dictionary dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString namespaceUri = WsrmIndex.GetNamespace(reliableMessagingVersion);
writer.WriteStartElement(dictionary.Identifier, namespaceUri);
writer.WriteValue(sequenceId);
writer.WriteEndElement();
if (ranges.Count == 0)
{
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
ranges = ranges.MergeWith((long)0L);
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
writer.WriteStartElement(DXD.Wsrm11Dictionary.None, namespaceUri);
writer.WriteEndElement();
}
}
for (int i = 0; i < ranges.Count; i++)
{
writer.WriteStartElement(dictionary.AcknowledgementRange, namespaceUri);
writer.WriteStartAttribute(dictionary.Lower, null);
SequenceRange range = ranges[i];
writer.WriteValue(range.Lower);
writer.WriteEndAttribute();
writer.WriteStartAttribute(dictionary.Upper, null);
SequenceRange range2 = ranges[i];
writer.WriteValue(range2.Upper);
writer.WriteEndAttribute();
writer.WriteEndElement();
}
}
public MessageNumberRolloverFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader,
ReliableMessagingVersion reliableMessagingVersion)
: base(code, WsrmFeb2005Strings.MessageNumberRollover, reason, true, true)
{
try
{
this.SequenceID = WsrmUtilities.ReadIdentifier(detailReader, reliableMessagingVersion);
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
detailReader.ReadStartElement(DXD.Wsrm11Dictionary.MaxMessageNumber,
WsrmIndex.GetNamespace(reliableMessagingVersion));
string maxMessageNumberString = detailReader.ReadContentAsString();
ulong maxMessageNumber;
if (!UInt64.TryParse(maxMessageNumberString, out maxMessageNumber) ||
(maxMessageNumber <= 0))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
SR.GetString(SR.InvalidSequenceNumber, maxMessageNumber)));
}
// otherwise ignore value
detailReader.ReadEndElement();
}
}
finally
{
detailReader.Close();
}
}
static void LookupDetailInformation(ReliableMessagingVersion reliableMessagingVersion, string subcode,
out string detailName, out string detailNamespace)
{
detailName = null;
detailNamespace = null;
string wsrmNs = WsrmIndex.GetNamespaceString(reliableMessagingVersion);
bool wsrmFeb2005 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool wsrm11 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
if (subcode == WsrmFeb2005Strings.InvalidAcknowledgement)
{
detailName = WsrmFeb2005Strings.SequenceAcknowledgement;
detailNamespace = wsrmNs;
}
else if ((subcode == WsrmFeb2005Strings.MessageNumberRollover) ||
(subcode == WsrmFeb2005Strings.SequenceTerminated) ||
(subcode == WsrmFeb2005Strings.UnknownSequence) ||
(wsrmFeb2005 && (subcode == WsrmFeb2005Strings.LastMessageNumberExceeded)) ||
(wsrm11 && (subcode == Wsrm11Strings.SequenceClosed)))
{
detailName = WsrmFeb2005Strings.Identifier;
detailNamespace = wsrmNs;
}
else
{
detailName = null;
detailNamespace = null;
}
}
internal static Message CreateTerminateMessage(MessageVersion version, ReliableMessagingVersion reliableMessagingVersion, UniqueId id, long last)
{
Message message = Message.CreateMessage(version, WsrmIndex.GetTerminateSequenceActionHeader(version.Addressing, reliableMessagingVersion), new TerminateSequence(reliableMessagingVersion, id, last));
message.Properties.AllowOutputBatching = false;
return(message);
}
internal static UniqueId GetOutputId(ReliableMessagingVersion reliableMessagingVersion, WsrmMessageInfo info)
{
if (info.AcknowledgementInfo != null)
{
return(info.AcknowledgementInfo.SequenceID);
}
if ((info.WsrmHeaderFault != null) && info.WsrmHeaderFault.FaultsOutput)
{
return(info.WsrmHeaderFault.SequenceID);
}
if (info.TerminateSequenceResponseInfo != null)
{
return(info.TerminateSequenceResponseInfo.Identifier);
}
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (info.CloseSequenceInfo != null)
{
return(info.CloseSequenceInfo.Identifier);
}
if (info.CloseSequenceResponseInfo != null)
{
return(info.CloseSequenceResponseInfo.Identifier);
}
if (info.TerminateSequenceResponseInfo != null)
{
return(info.TerminateSequenceResponseInfo.Identifier);
}
}
return(null);
}
private static Message CreateCSRefusedFault(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, bool isSenderFault, FaultCode subCode, string reason)
{
FaultCode code;
if (messageVersion.Envelope == EnvelopeVersion.Soap11)
{
code = new FaultCode("CreateSequenceRefused", WsrmIndex.GetNamespaceString(reliableMessagingVersion));
}
else
{
if (messageVersion.Envelope != EnvelopeVersion.Soap12)
{
throw Fx.AssertAndThrow("Unsupported version.");
}
if (subCode == null)
{
subCode = new FaultCode("CreateSequenceRefused", WsrmIndex.GetNamespaceString(reliableMessagingVersion), subCode);
}
if (isSenderFault)
{
code = FaultCode.CreateSenderFaultCode(subCode);
}
else
{
code = FaultCode.CreateReceiverFaultCode(subCode);
}
}
FaultReason reason2 = new FaultReason(System.ServiceModel.SR.GetString("CSRefused", new object[] { reason }), CultureInfo.CurrentCulture);
MessageFault fault = MessageFault.CreateFault(code, reason2);
string faultActionString = WsrmIndex.GetFaultActionString(messageVersion.Addressing, reliableMessagingVersion);
return(Message.CreateMessage(messageVersion, fault, faultActionString));
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (typeof(string) == destinationType && value is ReliableMessagingVersion)
{
ReliableMessagingVersion version = (ReliableMessagingVersion)value;
if (version == ReliableMessagingVersion.Default)
{
return(ConfigurationStrings.Default);
}
else if (version == ReliableMessagingVersion.WSReliableMessaging11)
{
return(ConfigurationStrings.WSReliableMessaging11);
}
else if (version == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
return(ConfigurationStrings.WSReliableMessagingFebruary2005);
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value",
SR.GetString(SR.ConfigInvalidClassInstanceValue, typeof(ReliableMessagingVersion).FullName)));
}
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public TransmissionStrategy(ReliableMessagingVersion reliableMessagingVersion, TimeSpan initRtt,
int maxWindowSize, bool requestAcks, UniqueId id)
{
if (initRtt < TimeSpan.Zero)
{
if (DiagnosticUtility.ShouldTrace(TraceEventType.Warning))
{
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.WsrmNegativeElapsedTimeDetected,
SR.TraceCodeWsrmNegativeElapsedTimeDetected, this);
}
initRtt = ReliableMessagingConstants.UnknownInitiationTime;
}
if (maxWindowSize <= 0)
{
throw Fx.AssertAndThrow("Argument maxWindow size must be positive.");
}
_id = id;
_maxWindowSize = _lossWindowSize = maxWindowSize;
_meanRtt = Math.Min((long)initRtt.TotalMilliseconds, Constants.MaxMeanRtt >> Constants.TimeMultiplier) << Constants.TimeMultiplier;
_serrRtt = _meanRtt >> 1;
_window = new SlidingWindow(maxWindowSize);
_slowStartThreshold = maxWindowSize;
_timeout = Math.Max(((200 << Constants.TimeMultiplier) * 2) + _meanRtt, _meanRtt + (_serrRtt << Constants.ChebychevFactor));
QuotaRemaining = int.MaxValue;
_retryTimer = new IOThreadTimer(new Func <object, Task>(OnRetryElapsed), null, true);
_requestAcks = requestAcks;
_reliableMessagingVersion = reliableMessagingVersion;
}
public WsrmAcknowledgmentHeader(ReliableMessagingVersion reliableMessagingVersion, UniqueId sequenceID, SequenceRangeCollection ranges, bool final, int bufferRemaining) : base(reliableMessagingVersion)
{
this.sequenceID = sequenceID;
this.ranges = ranges;
this.final = final;
this.bufferRemaining = bufferRemaining;
}
void TerminateSequence(TimeSpan timeout)
{
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
this.session.CloseSession();
Message message = WsrmUtilities.CreateTerminateMessage(this.settings.MessageVersion,
reliableMessagingVersion, this.session.OutputID);
this.OnConnectionSendMessage(message, timeout, MaskingMode.Handled);
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
this.CreateTerminateRequestor();
Message terminateReply = this.terminateRequestor.Request(timeout);
if (terminateReply != null)
{
this.ProcessCloseOrTerminateReply(false, terminateReply);
}
}
else
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
}
private async Task TerminateSequenceAsync(TimeSpan timeout)
{
ReliableMessagingVersion reliableMessagingVersion = Settings.ReliableMessagingVersion;
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
_session.CloseSession();
Message message = WsrmUtilities.CreateTerminateMessage(Settings.MessageVersion,
reliableMessagingVersion, _session.OutputID);
await OnConnectionSendMessageAsync(message, timeout, MaskingMode.Handled);
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
CreateTerminateRequestor();
Message terminateReply = await _terminateRequestor.RequestAsync(timeout);
if (terminateReply != null)
{
ProcessCloseOrTerminateReply(false, terminateReply);
}
}
else
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
}
public static async Task EchoCall(ReliableMessagingVersion rmVersion, bool ordered, string endpointSuffix)
{
string testString = "Hello";
ChannelFactory <IWcfReliableService> factory = null;
IWcfReliableService serviceProxy = null;
WSHttpBinding binding = null;
try
{
// *** SETUP *** \\
binding = new WSHttpBinding(SecurityMode.None, true);
binding.ReliableSession.Ordered = ordered;
var customBinding = new CustomBinding(binding);
var reliableSessionBindingElement = customBinding.Elements.Find <ReliableSessionBindingElement>();
reliableSessionBindingElement.ReliableMessagingVersion = rmVersion;
factory = new ChannelFactory <IWcfReliableService>(customBinding, new EndpointAddress(Endpoints.ReliableSession_WSHttp + endpointSuffix));
serviceProxy = factory.CreateChannel();
// *** EXECUTE *** \\
((IClientChannel)serviceProxy).Open(); // This will establish a reliable session
var result = await serviceProxy.EchoAsync(testString);
// *** VALIDATE *** \\
Assert.Equal(testString, result);
// *** CLEANUP *** \\
((IClientChannel)serviceProxy).Close();
factory.Close();
((ICommunicationObject)serviceProxy).Close();
}
finally
{
// *** ENSURE CLEANUP *** \\
ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
}
}
public TerminateSequence(ReliableMessagingVersion reliableMessagingVersion, UniqueId identifier, long last)
: base(true)
{
_reliableMessagingVersion = reliableMessagingVersion;
_identifier = identifier;
_lastMsgNumber = last;
}
public CreateSequenceResponse(AddressingVersion addressingVersion,
ReliableMessagingVersion reliableMessagingVersion)
: base(true)
{
_addressingVersion = addressingVersion;
_reliableMessagingVersion = reliableMessagingVersion;
}
public static string GetSubcode(XmlDictionaryReader headerReader, ReliableMessagingVersion reliableMessagingVersion)
{
string localName = null;
try
{
string str3;
WsrmFeb2005Dictionary dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString namespaceUri = WsrmIndex.GetNamespace(reliableMessagingVersion);
headerReader.ReadStartElement(dictionary.SequenceFault, namespaceUri);
headerReader.ReadStartElement(dictionary.FaultCode, namespaceUri);
XmlUtil.ReadContentAsQName(headerReader, out localName, out str3);
if (str3 != WsrmIndex.GetNamespaceString(reliableMessagingVersion))
{
localName = null;
}
headerReader.ReadEndElement();
while (headerReader.IsStartElement())
{
headerReader.Skip();
}
headerReader.ReadEndElement();
}
finally
{
headerReader.Close();
}
return(localName);
}
public ClientReliableSession(ChannelBase channel, IReliableFactorySettings factory, IClientReliableChannelBinder binder, FaultHelper faultHelper, UniqueId inputID) : base(channel, factory, binder, faultHelper)
{
this.binder = binder;
base.InputID = inputID;
this.pollingTimer = new InterruptibleTimer(this.GetPollingInterval(), new WaitCallback(this.OnPollingTimerElapsed), null);
if (this.binder.Channel is IRequestChannel)
{
this.requestor = new RequestReliableRequestor();
}
else if (this.binder.Channel is IDuplexChannel)
{
SendReceiveReliableRequestor requestor = new SendReceiveReliableRequestor {
TimeoutIsSafe = !this.ChannelSupportsOneCreateSequenceAttempt()
};
this.requestor = requestor;
}
MessageVersion messageVersion = base.Settings.MessageVersion;
ReliableMessagingVersion reliableMessagingVersion = base.Settings.ReliableMessagingVersion;
this.requestor.MessageVersion = messageVersion;
this.requestor.Binder = this.binder;
this.requestor.IsCreateSequence = true;
this.requestor.TimeoutString1Index = "TimeoutOnOpen";
this.requestor.MessageAction = WsrmIndex.GetCreateSequenceActionHeader(messageVersion.Addressing, reliableMessagingVersion);
if ((reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11) && (this.binder.GetInnerSession() is ISecureConversationSession))
{
this.requestor.MessageHeader = new WsrmUsesSequenceSTRHeader();
}
this.requestor.MessageBody = new CreateSequence(base.Settings.MessageVersion.Addressing, reliableMessagingVersion, base.Settings.Ordered, this.binder, base.InputID);
this.requestor.SetRequestResponsePattern();
}
public TerminateSequence(ReliableMessagingVersion reliableMessagingVersion, UniqueId identifier, Int64 last)
: base(true)
{
this.reliableMessagingVersion = reliableMessagingVersion;
this.identifier = identifier;
this.lastMsgNumber = last;
}
public CreateSequenceResponse(AddressingVersion addressingVersion,
ReliableMessagingVersion reliableMessagingVersion)
: base(true)
{
this.addressingVersion = addressingVersion;
this.reliableMessagingVersion = reliableMessagingVersion;
}
public static bool TryCreateFault12(ReliableMessagingVersion reliableMessagingVersion, Message message,
MessageFault fault, out WsrmHeaderFault wsrmFault)
{
// All wsrm header faults must be sender or receiver faults.
if (!fault.Code.IsSenderFault && !fault.Code.IsReceiverFault)
{
wsrmFault = null;
return(false);
}
if ((fault.Code.SubCode == null) ||
(fault.Code.SubCode.Namespace != WsrmIndex.GetNamespaceString(reliableMessagingVersion)) || !fault.HasDetail)
{
wsrmFault = null;
return(false);
}
string subcodeName = fault.Code.SubCode.Name;
XmlDictionaryReader detailReader = fault.GetReaderAtDetailContents();
wsrmFault = CreateWsrmHeaderFault(reliableMessagingVersion, fault.Code, subcodeName, fault.Reason,
detailReader);
return(wsrmFault != null);
}
public Message CreateMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion)
{
this.SetReliableMessagingVersion(reliableMessagingVersion);
string action = WsrmIndex.GetFaultActionString(messageVersion.Addressing, reliableMessagingVersion);
if (messageVersion.Envelope == EnvelopeVersion.Soap11)
{
this.code = this.Get11Code(this.code, this.subcode);
}
else if (messageVersion.Envelope == EnvelopeVersion.Soap12)
{
if (this.code.SubCode == null)
{
FaultCode subCode = new FaultCode(this.subcode,
WsrmIndex.GetNamespaceString(reliableMessagingVersion));
this.code = new FaultCode(this.code.Name, this.code.Namespace, subCode);
}
this.hasDetail = this.Get12HasDetail();
}
else
{
throw Fx.AssertAndThrow("Unsupported MessageVersion.");
}
Message message = Message.CreateMessage(messageVersion, this, action);
this.OnFaultMessageCreated(messageVersion, message);
return(message);
}
internal static void AssertWsrm11(ReliableMessagingVersion reliableMessagingVersion)
{
if (reliableMessagingVersion != ReliableMessagingVersion.WSReliableMessaging11)
{
throw Fx.AssertAndThrow("WS-ReliableMessaging 1.1 required.");
}
}
internal static bool IsWsrmAction(ReliableMessagingVersion reliableMessagingVersion, string action)
{
if (action == null)
{
return(false);
}
return(action.StartsWith(WsrmIndex.GetNamespaceString(reliableMessagingVersion), StringComparison.Ordinal));
}
public static UniqueId ReadIdentifier(XmlDictionaryReader reader, ReliableMessagingVersion reliableMessagingVersion)
{
reader.ReadStartElement(XD.WsrmFeb2005Dictionary.Identifier, WsrmIndex.GetNamespace(reliableMessagingVersion));
UniqueId id = reader.ReadContentAsUniqueId();
reader.ReadEndElement();
return(id);
}
public CreateSequence(AddressingVersion addressingVersion, ReliableMessagingVersion reliableMessagingVersion, bool ordered, IClientReliableChannelBinder binder, UniqueId offerIdentifier) : base(true)
{
this.addressingVersion = addressingVersion;
this.reliableMessagingVersion = reliableMessagingVersion;
this.ordered = ordered;
this.binder = binder;
this.offerIdentifier = offerIdentifier;
}
internal static Message CreateAcknowledgmentMessage(MessageVersion version, ReliableMessagingVersion reliableMessagingVersion, UniqueId id, SequenceRangeCollection ranges, bool final, int bufferRemaining)
{
Message message = Message.CreateMessage(version, WsrmIndex.GetSequenceAcknowledgementActionHeader(version.Addressing, reliableMessagingVersion));
AddAcknowledgementHeader(reliableMessagingVersion, message, id, ranges, final, bufferRemaining);
message.Properties.AllowOutputBatching = false;
return(message);
}
internal static string GetTerminateSequenceResponseActionString(ReliableMessagingVersion reliableMessagingVersion)
{
if (reliableMessagingVersion != ReliableMessagingVersion.WSReliableMessaging11)
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
return("http://docs.oasis-open.org/ws-rx/wsrm/200702/TerminateSequenceResponse");
}
private void ConfigureRequestor(ReliableRequestor requestor)
{
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
requestor.MessageVersion = this.settings.MessageVersion;
requestor.Binder = this.binder;
requestor.SetRequestResponsePattern();
requestor.MessageHeader = new WsrmAcknowledgmentHeader(reliableMessagingVersion, this.session.InputID, this.ranges, true, -1);
}
protected override void OnWriteDetailContents(XmlDictionaryWriter writer)
{
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
ReliableMessagingVersion reliableMessagingVersion = this.GetReliableMessagingVersion();
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
writer.WriteStartElement(wsrmFeb2005Dictionary.SequenceAcknowledgement, wsrmNs);
WsrmAcknowledgmentHeader.WriteAckRanges(writer, reliableMessagingVersion, this.SequenceID, this.ranges);
writer.WriteEndElement();
}
public ReliableOutputConnection(UniqueId id,
int maxTransferWindowSize,
MessageVersion messageVersion,
ReliableMessagingVersion reliableMessagingVersion,
TimeSpan initialRtt,
bool requestAcks,
TimeSpan sendTimeout)
{
this.id = id;
this.messageVersion = messageVersion;
this.reliableMessagingVersion = reliableMessagingVersion;
this.sendTimeout = sendTimeout;
this.strategy = new TransmissionStrategy(reliableMessagingVersion, initialRtt, maxTransferWindowSize,
requestAcks, id);
this.strategy.RetryTimeoutElapsed = OnRetryTimeoutElapsed;
this.strategy.OnException = RaiseOnException;
}
public static CreateSequenceResponseInfo Create(AddressingVersion addressingVersion,
ReliableMessagingVersion reliableMessagingVersion, XmlDictionaryReader reader)
{
if (reader == null)
{
Fx.Assert("Argument reader cannot be null.");
}
CreateSequenceResponseInfo createSequenceResponse = new CreateSequenceResponseInfo();
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
reader.ReadStartElement(wsrmFeb2005Dictionary.CreateSequenceResponse, wsrmNs);
reader.ReadStartElement(wsrmFeb2005Dictionary.Identifier, wsrmNs);
createSequenceResponse.Identifier = reader.ReadContentAsUniqueId();
reader.ReadEndElement();
if (reader.IsStartElement(wsrmFeb2005Dictionary.Expires, wsrmNs))
{
reader.ReadElementContentAsTimeSpan();
}
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (reader.IsStartElement(DXD.Wsrm11Dictionary.IncompleteSequenceBehavior, wsrmNs))
{
string incompleteSequenceBehavior = reader.ReadElementContentAsString();
if ((incompleteSequenceBehavior != Wsrm11Strings.DiscardEntireSequence)
&& (incompleteSequenceBehavior != Wsrm11Strings.DiscardFollowingFirstGap)
&& (incompleteSequenceBehavior != Wsrm11Strings.NoDiscard))
{
string reason = SR.GetString(SR.CSResponseWithInvalidIncompleteSequenceBehavior);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(reason));
}
// Otherwise ignore the value.
}
}
if (reader.IsStartElement(wsrmFeb2005Dictionary.Accept, wsrmNs))
{
reader.ReadStartElement();
createSequenceResponse.AcceptAcksTo = EndpointAddress.ReadFrom(addressingVersion, reader,
wsrmFeb2005Dictionary.AcksTo, wsrmNs);
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
}
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
return createSequenceResponse;
}
