public Microsoft.ServiceBus.Channels.IConnection Connect(Uri uri, TimeSpan timeout)
{
EventTraceActivity eventTraceActivity = new EventTraceActivity();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
WebStream webStream = (new WebStream(uri, "connection", this.useHttpsMode, eventTraceActivity, uri)).Open();
Microsoft.ServiceBus.Channels.IConnection webStreamConnection = new WebStreamConnection(uri, this.bufferSize, eventTraceActivity, webStream, uri);
webStreamConnection = SecureSocketUtil.InitiateSecureClientUpgradeIfNeeded(webStreamConnection, null, this.socketSecurityRole, uri.Host, timeoutHelper.RemainingTime());
SocketMessageHelper socketMessageHelper = new SocketMessageHelper();
Message message = Message.CreateMessage(socketMessageHelper.MessageVersion, "RelayedConnect", new ConnectMessage(uri));
TrackingIdHeader.TryAddOrUpdate(message.Headers, eventTraceActivity.ActivityId.ToString());
if (this.tokenProvider != null)
{
string absoluteUri = RelayedHttpUtility.ConvertToHttpUri(uri).AbsoluteUri;
SecurityToken token = this.tokenProvider.GetToken(absoluteUri, "Send", false, timeoutHelper.RemainingTime());
message.Headers.Add(new RelayTokenHeader(token));
}
socketMessageHelper.SendMessage(webStreamConnection, message, timeoutHelper.RemainingTime());
Message message1 = socketMessageHelper.ReceiveMessage(webStreamConnection, timeoutHelper.RemainingTime());
if (message1.IsFault)
{
throw ErrorUtility.ConvertToError(MessageFault.CreateFault(message1, 65536));
}
return(webStreamConnection);
}
public Microsoft.ServiceBus.Channels.IConnection Connect(Uri uri, TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
Uri uri1 = uri;
for (int i = 0; i < 3; i++)
{
EventTraceActivity eventTraceActivity = new EventTraceActivity();
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
socket.Connect(uri1.Host, 9352);
Microsoft.ServiceBus.Channels.IConnection socketConnection = new Microsoft.ServiceBus.Channels.SocketConnection(socket, this.bufferSize, eventTraceActivity);
byte[] bytes = Encoding.UTF8.GetBytes(ConnectConstants.ConnectType);
byte[] numArray = BitConverter.GetBytes((int)bytes.Length);
socketConnection.Write(numArray, 0, (int)numArray.Length, true, timeoutHelper.RemainingTime());
socketConnection.Write(bytes, 0, (int)bytes.Length, true, timeoutHelper.RemainingTime());
byte[] bytes1 = Encoding.UTF8.GetBytes(uri1.ToString());
byte[] numArray1 = BitConverter.GetBytes((int)bytes1.Length);
socketConnection.Write(numArray1, 0, (int)numArray1.Length, true, timeoutHelper.RemainingTime());
socketConnection.Write(bytes1, 0, (int)bytes1.Length, true, timeoutHelper.RemainingTime());
socketConnection = SecureSocketUtil.InitiateSecureClientUpgradeIfNeeded(socketConnection, null, this.socketSecurityMode, uri.Host, timeoutHelper.RemainingTime());
Message message = Message.CreateMessage(this.messageHelper.MessageVersion, "RelayedConnect", new ConnectMessage(uri));
TrackingIdHeader.TryAddOrUpdate(message.Headers, eventTraceActivity.ActivityId.ToString());
if (this.tokenProvider != null)
{
SecurityToken token = this.tokenProvider.GetToken(RelayedHttpUtility.ConvertToHttpUri(uri).ToString(), "Send", false, timeoutHelper.RemainingTime());
message.Headers.Add(new RelayTokenHeader(token));
}
this.messageHelper.SendMessage(socketConnection, message, timeoutHelper.RemainingTime());
Message message1 = this.messageHelper.ReceiveMessage(socketConnection, timeoutHelper.RemainingTime());
using (message1)
{
if (message1.Headers.Action == "Redirect")
{
uri1 = message1.GetBody<RedirectMessage>().Uri;
socket.Close();
goto Label1;
}
else if (message1.IsFault)
{
MessageFault messageFault = MessageFault.CreateFault(message1, 65536);
throw Fx.Exception.AsError(ErrorUtility.ConvertToError(messageFault), eventTraceActivity);
}
}
return socketConnection;
}
catch
{
socket.Close();
throw;
}
Label1:
}
throw Fx.Exception.AsError(new CommunicationException(SRClient.MaxRedirectsExceeded(3)), null);
}
public DuplexCorrelationAsyncResult(DuplexRequestBindingElement.DuplexRequestSessionChannel parent, Message wcfRequest, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
{
TrackingIdHeader trackingIdHeader;
DuplexRequestBindingElement.DuplexRequestSessionChannel.DuplexCorrelationAsyncResult duplexCorrelationAsyncResult;
this.parent = parent;
this.OriginalTimeout = timeout;
this.wcfRequest = wcfRequest;
this.RequestMessageId = this.wcfRequest.Headers.MessageId;
if (this.RequestMessageId == null)
{
this.RequestMessageId = new UniqueId();
this.wcfRequest.Headers.MessageId = this.RequestMessageId;
}
this.requestAction = this.wcfRequest.Headers.Action;
if (!TrackingIdHeader.TryRead(this.wcfRequest.Headers, out trackingIdHeader))
{
this.clientTrackingId = this.RequestMessageId.ToString();
}
else
{
this.clientTrackingId = trackingIdHeader.Id;
}
this.parent.inflightRequests[this.RequestMessageId] = this;
this.parent.OnBeginRequest();
if (timeout != TimeSpan.MaxValue)
{
this.timer = new IOThreadTimer(DuplexRequestBindingElement.DuplexRequestSessionChannel.DuplexCorrelationAsyncResult.timerCallback, this, false);
this.timer.Set(timeout);
}
lock (base.ThisLock)
{
try
{
if (base.SyncContinue(this.parent.innerChannel.BeginSend(this.wcfRequest, timeout, base.PrepareAsyncCompletion(DuplexRequestBindingElement.DuplexRequestSessionChannel.DuplexCorrelationAsyncResult.sendCompletion), this)))
{
this.TryComplete(true, null);
}
}
catch (Exception exception1)
{
Exception exception = exception1;
if (Fx.IsFatal(exception))
{
throw;
}
this.parent.inflightRequests.TryRemove(this.RequestMessageId, out duplexCorrelationAsyncResult);
this.TryComplete(true, exception);
}
}
}
private Message CreateWcfMessageInternal(string action, object body, bool includeToken, string parentLinkId, RetryPolicy policy, TrackingContext trackingContext, RequestInfo requestInfo)
{
Message message = Message.CreateMessage(this.messageVersion, action, body);
MessageHeaders headers = message.Headers;
headers.To = this.targetAddress.Uri;
string sufficientClaims = this.GetSufficientClaims();
if (this.linkInfo != null)
{
if (!string.IsNullOrEmpty(this.linkInfo.TransferDestinationEntityAddress))
{
SecurityToken authorizationToken = this.GetAuthorizationToken(this.linkInfo.TransferDestinationEntityAddress, sufficientClaims);
if (authorizationToken != null)
{
SimpleWebSecurityToken simpleWebSecurityToken = (SimpleWebSecurityToken)authorizationToken;
if (simpleWebSecurityToken != null)
{
this.linkInfo.TransferDestinationAuthorizationToken = simpleWebSecurityToken.Token;
}
}
}
this.linkInfo.AddTo(headers);
}
if (includeToken)
{
ServiceBusAuthorizationHeader authorizationHeader = this.GetAuthorizationHeader(sufficientClaims);
if (authorizationHeader != null)
{
headers.Add(authorizationHeader);
}
}
if (this.messagingFactory.FaultInjectionInfo != null)
{
this.messagingFactory.FaultInjectionInfo.AddToHeader(message);
}
if (!string.IsNullOrWhiteSpace(parentLinkId))
{
message.Properties["ParentLinkId"] = parentLinkId;
}
if (trackingContext != null)
{
TrackingIdHeader.TryAddOrUpdate(headers, trackingContext.TrackingId);
}
message.AddHeaderIfNotNull <RequestInfo>("RequestInfo", "http://schemas.microsoft.com/netservices/2011/06/servicebus", requestInfo);
return(message);
}
protected override RelayedOnewayTcpClient.RelayedOnewayConnection Connect(TimeSpan timeout)
{
RelayedOnewayTcpClient.RelayedOnewayConnection relayedOnewayConnection;
Microsoft.ServiceBus.Common.TimeoutHelper timeoutHelper = new Microsoft.ServiceBus.Common.TimeoutHelper(timeout);
Message uniqueId = Message.CreateMessage(base.MessageVersion, "http://schemas.microsoft.com/netservices/2009/05/servicebus/connect/Connect", new ConnectMessage(base.Uri));
TrackingIdHeader.TryAddOrUpdate(uniqueId.Headers, base.Activity.ActivityId.ToString());
uniqueId.Headers.MessageId = new UniqueId();
uniqueId.Headers.ReplyTo = EndpointAddress2.AnonymousAddress;
if (base.TokenProvider != null)
{
SecurityToken token = base.TokenProvider.GetToken(base.AppliesTo, "Send", false, timeoutHelper.RemainingTime());
uniqueId.Headers.Add(new RelayTokenHeader(token));
}
using (RelayedOnewayTcpClient.ConnectRequestReplyContext connectRequestReplyContext = new RelayedOnewayTcpClient.ConnectRequestReplyContext(this))
{
connectRequestReplyContext.Send(uniqueId, timeoutHelper.RemainingTime(), out relayedOnewayConnection);
}
return(relayedOnewayConnection);
}
private void SendRelayedConnectAndReceiveResponse(ClientWebSocketConnection connection, TimeoutHelper timeoutHelper)
{
SocketMessageHelper socketMessageHelper = new SocketMessageHelper();
Message message = Message.CreateMessage(socketMessageHelper.MessageVersion, "RelayedConnect", new ConnectMessage(connection.Uri));
TrackingIdHeader.TryAddOrUpdate(message.Headers, connection.Activity.ActivityId.ToString());
if (this.tokenProvider != null)
{
string absoluteUri = RelayedHttpUtility.ConvertToHttpUri(connection.Uri).AbsoluteUri;
SecurityToken token = this.tokenProvider.GetToken(absoluteUri, "Send", false, timeoutHelper.RemainingTime());
message.Headers.Add(new RelayTokenHeader(token));
}
socketMessageHelper.SendMessage(connection, message, timeoutHelper.RemainingTime());
Message message1 = socketMessageHelper.ReceiveMessage(connection, timeoutHelper.RemainingTime());
if (message1.IsFault)
{
throw ErrorUtility.ConvertToError(MessageFault.CreateFault(message1, 65536));
}
}
