internal static InternalConnectivityMode GetInternalConnectivityMode(ConnectivitySettings connectivitySettings, HttpConnectivitySettings httpConnectivitySettings, Uri uri)
{
if (connectivitySettings == null && httpConnectivitySettings == null && ServiceBusEnvironment.SystemConnectivity.Mode == ConnectivityMode.AutoDetect && ConnectivityModeHelper.OverrideInternalConnectivityMode.HasValue)
{
return(ConnectivityModeHelper.OverrideInternalConnectivityMode.Value);
}
ConnectivityMode connectivityMode = (connectivitySettings != null ? connectivitySettings.Mode : ServiceBusEnvironment.SystemConnectivity.Mode);
return(ConnectivityModeHelper.GetInternalConnectivityMode(connectivityMode, (httpConnectivitySettings != null ? httpConnectivitySettings.Mode : HttpConnectivityMode.AutoDetect), uri));
}
/// <summary>
/// Initializes a new instance of the <see cref="IdentifiedFeatureViewModel"/> class.
/// </summary>
public IdentifiedFeatureViewModel(Feature feature, ConnectivityMode connectivityMode)
{
if (feature != null)
{
Feature = feature;
FeatureTable = feature.FeatureTable as ArcGISFeatureTable;
PopupManager = new PopupManager(new Popup(feature, FeatureTable.PopupDefinition));
ConnectivityMode = connectivityMode;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IdentifiedFeatureViewModel"/> class.
/// </summary>
public IdentifiedFeatureViewModel(Feature feature, FeatureTable featureTable, ConnectivityMode connectivityMode)
{
if (feature != null)
{
Feature = feature;
PopupManager = new PopupManager(new Popup(feature, featureTable.PopupDefinition));
Fields = FieldContainer.GetFields(PopupManager);
FeatureTable = featureTable;
ConnectivityMode = connectivityMode;
}
}
public SbmpMessagingFactory(IEnumerable <Uri> baseAddresses, NetMessagingTransportSettings settings)
{
bool flag;
ConnectivityMode systemConnectivityMode = ConnectivityModeHelper.SystemConnectivityMode;
this.connectionId = Guid.NewGuid().ToString("N");
this.Settings = (NetMessagingTransportSettings)settings.Clone();
if (systemConnectivityMode == ConnectivityMode.AutoDetect && !this.Settings.GatewayMode)
{
this.baseAddresses = new List <Uri>(baseAddresses);
this.FirstInBaseAddress = this.baseAddresses.First <Uri>();
return;
}
flag = (systemConnectivityMode != ConnectivityMode.Http ? false : true);
this.Initialize(flag, baseAddresses);
}
public static IRelayedOnewaySender CreateConnection(BindingContext context, RelayedOnewayTransportBindingElement transportBindingElement, Uri uri)
{
ConnectivitySettings connectivitySetting = context.BindingParameters.Find <ConnectivitySettings>();
NameSettings nameSetting = context.BindingParameters.Find <NameSettings>();
ConnectivityMode connectivityMode = (connectivitySetting != null ? connectivitySetting.Mode : ConnectivityModeHelper.SystemConnectivityMode);
if (connectivityMode == ConnectivityMode.AutoDetect)
{
connectivityMode = NetworkDetector.DetectConnectivityModeForAutoDetect(uri);
}
if (connectivityMode != ConnectivityMode.Tcp)
{
return(new RelayedOnewayHttpSender(context, uri, nameSetting.ServiceSettings.TransportProtection == RelayTransportProtectionMode.EndToEnd));
}
return(new RelayedOnewayTcpSender(context, transportBindingElement, uri, nameSetting.ServiceSettings.TransportProtection == RelayTransportProtectionMode.EndToEnd, new EventTraceActivity()));
}
/// <summary>
/// Initializes a new instance of the <see cref="MapViewModel"/> class.
/// </summary>
public MapViewModel(Map map, ConnectivityMode connectivityMode, int defaultZoomScale)
{
ConnectivityMode = connectivityMode;
_defaultZoomScale = defaultZoomScale;
// Initialize the map
Map = map;
Map.LoadStatusChanged += Map_LoadStatusChanged;
Map.LoadAsync();
// Initialize the location data source for device location
LocationDataSource = new SystemLocationDataSource();
LocationDataSource.LocationChanged += (s, l) =>
{
_lastLocation = l;
IsLocationStarted = true;
};
}
static void ConfigureWcfSendCommand(CommandLineApplication wcfCommand)
{
wcfCommand.RelayCommand("send", (sendCmd) =>
{
sendCmd.Description = "WcfRelay send command";
var pathArgument = sendCmd.Argument("path", "WcfRelay path");
var connectionStringArgument = sendCmd.Argument("connectionString", "Relay ConnectionString");
var numberOption = sendCmd.Option(CommandStrings.NumberTemplate, CommandStrings.NumberDescription, CommandOptionType.SingleValue);
var bindingOption = sendCmd.Option(BindingOptionTemplate, BindingOptionDescription, CommandOptionType.SingleValue);
var noClientAuthOption = sendCmd.Option("--no-client-auth", "Skip client authentication", CommandOptionType.NoValue);
var connectivityModeOption = sendCmd.Option(CommandStrings.ConnectivityModeTemplate, CommandStrings.ConnectivityModeDescription, CommandOptionType.SingleValue);
var requestOption = sendCmd.Option(CommandStrings.RequestTemplate, CommandStrings.RequestDescription, CommandOptionType.SingleValue);
var requestDelayOption = sendCmd.Option("-rd|--request-delay <delay>", "A TimeSpan indicating how long the listener should delay before responding to request", CommandOptionType.SingleValue);
var openTimeoutOption = sendCmd.Option("-ot|--open-timeout <timeout>", "A TimeSpan for configuring the Binding.OpenTimeout", CommandOptionType.SingleValue);
var sendTimeoutOption = sendCmd.Option("-st|--send-timeout <timeout>", "A TimeSpan for configuring the Binding.SendTimeout", CommandOptionType.SingleValue);
var readTimeoutOption = sendCmd.Option("-rt|--receive-timeout <timeout>", "A TimeSpan for configuring the Binding.ReceiveTimeout", CommandOptionType.SingleValue);
var protocolOption = sendCmd.AddSecurityProtocolOption();
sendCmd.OnExecute(() =>
{
ConfigureSecurityProtocol(protocolOption);
string connectionString = ConnectionStringUtility.ResolveConnectionString(connectionStringArgument);
string path = pathArgument.Value ?? DefaultPath;
string request = GetStringOption(requestOption, "Test Message Data");
if (string.IsNullOrEmpty(connectionString))
{
TraceMissingArgument(connectionStringArgument.Name);
sendCmd.ShowHelp();
return(1);
}
int number = GetIntOption(numberOption, 1);
var connectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString);
Binding binding = GetBinding(bindingOption, noClientAuthOption, openTimeoutOption, sendTimeoutOption, readTimeoutOption);
ConnectivityMode connectivityMode = GetConnectivityMode(connectivityModeOption);
TimeSpan requestDelay = requestDelayOption.HasValue() ? TimeSpan.Parse(requestDelayOption.Value()) : TimeSpan.Zero;
return(VerifySend(request, connectionStringBuilder, path, number, binding, noClientAuthOption.HasValue(), connectivityMode, requestDelay));
});
});
}
private static InternalConnectivityMode GetInternalConnectivityMode(ConnectivityMode detectMode, HttpConnectivityMode defaultHttpDetectMode, Uri uri)
{
if (detectMode == ConnectivityMode.Tcp)
{
return(InternalConnectivityMode.Tcp);
}
if (detectMode != ConnectivityMode.Http || defaultHttpDetectMode == HttpConnectivityMode.AutoDetect)
{
if (detectMode != ConnectivityMode.AutoDetect)
{
return(NetworkDetector.DetectInternalConnectivityModeForHttp(uri));
}
return(NetworkDetector.DetectInternalConnectivityModeForAutoDetect(uri));
}
if (defaultHttpDetectMode == HttpConnectivityMode.Http)
{
return(InternalConnectivityMode.Http);
}
if (defaultHttpDetectMode == HttpConnectivityMode.Https)
{
return(InternalConnectivityMode.Https);
}
return(InternalConnectivityMode.HttpsWebSocket);
}
protected override IEnumerator <IteratorTask <object> .TaskStep> GetTasks()
{
ConnectivityMode connectivityMode;
object obj = null;
bool flag = false;
try
{
object thisLock = this.relay.ThisLock;
object obj1 = thisLock;
obj = thisLock;
Monitor.Enter(obj1, ref flag);
if (this.relay.State != AmqpObjectState.OpenReceived && this.relay.State != AmqpObjectState.Opened)
{
goto Label0;
}
}
finally
{
if (flag)
{
Monitor.Exit(obj);
}
}
Microsoft.ServiceBus.Common.TimeoutHelper timeoutHelper = new Microsoft.ServiceBus.Common.TimeoutHelper(this.timeout);
string host = this.relay.serviceBusUri.Host;
AmqpSettings amqpSetting = AmqpRelay.ConnectTask.CreateAmqpSettings();
connectivityMode = (this.relay.connectivitySettings != null ? this.relay.connectivitySettings.Mode : ServiceBusEnvironment.SystemConnectivity.Mode);
ConnectivityMode connectivityMode1 = connectivityMode;
if (connectivityMode1 == ConnectivityMode.Tcp)
{
TcpTransportSettings tcpTransportSetting = new TcpTransportSettings()
{
Host = host,
Port = 5671
};
TlsTransportSettings tlsTransportSetting = new TlsTransportSettings(tcpTransportSetting)
{
TargetHost = host
};
AmqpTransportInitiator amqpTransportInitiator = new AmqpTransportInitiator(amqpSetting, tlsTransportSetting);
yield return(base.CallTask(amqpTransportInitiator.ConnectTaskAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
}
else if (connectivityMode1 == ConnectivityMode.Http || this.relay.httpConnectivitySettings != null)
{
WebSocketTransportSettings webSocketTransportSetting = new WebSocketTransportSettings(this.relay.serviceBusUri);
AmqpTransportInitiator amqpTransportInitiator1 = new AmqpTransportInitiator(amqpSetting, webSocketTransportSetting);
yield return(base.CallTask(amqpTransportInitiator1.ConnectTaskAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
}
else
{
TcpTransportSettings tcpTransportSetting1 = new TcpTransportSettings()
{
Host = host,
Port = 5671
};
TlsTransportSettings tlsTransportSetting1 = new TlsTransportSettings(tcpTransportSetting1)
{
TargetHost = host
};
AmqpTransportInitiator amqpTransportInitiator2 = new AmqpTransportInitiator(amqpSetting, tlsTransportSetting1);
yield return(base.CallTask(amqpTransportInitiator2.ConnectTaskAsync(Microsoft.ServiceBus.Common.TimeoutHelper.Divide(timeoutHelper.RemainingTime(), 2)), IteratorTask <TResult> .ExceptionPolicy.Continue));
if (base.LastTask.Exception != null)
{
if (timeoutHelper.RemainingTime() == TimeSpan.Zero)
{
throw base.LastTask.Exception;
}
WebSocketTransportSettings webSocketTransportSetting1 = new WebSocketTransportSettings(this.relay.serviceBusUri);
AmqpTransportInitiator amqpTransportInitiator3 = new AmqpTransportInitiator(amqpSetting, webSocketTransportSetting1);
yield return(base.CallTask(amqpTransportInitiator3.ConnectTaskAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
}
}
TransportBase transportBase = base.LastTaskResult <TransportBase>();
string[] strArrays = host.Split(new char[] { '.' });
strArrays[0] = string.Concat(strArrays[0], "-relay");
AmqpConnectionSettings amqpConnectionSetting = new AmqpConnectionSettings()
{
ContainerId = Guid.NewGuid().ToString(),
HostName = string.Join(".", strArrays)
};
this.relay.connection = new AmqpConnection(transportBase, amqpSetting, amqpConnectionSetting);
yield return(base.CallTask(this.relay.connection.OpenAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
AmqpSessionSettings amqpSessionSetting = new AmqpSessionSettings();
AmqpSession amqpSession = this.relay.connection.CreateSession(amqpSessionSetting);
yield return(base.CallTask(amqpSession.OpenAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
AmqpLinkSettings amqpLinkSetting = new AmqpLinkSettings()
{
Role = new bool?(false),
InitialDeliveryCount = new uint?(0),
LinkName = string.Concat("HttpRelayServer_Link_", Guid.NewGuid()),
Target = new Target(this.relay.serviceBusUri),
Source = new Source(this.relay.serviceBusUri),
TotalLinkCredit = 1000,
AutoSendFlow = true
};
AmqpLinkSettings amqpLinkSetting1 = amqpLinkSetting;
if (this.relay.tokenRenewer != null)
{
amqpLinkSetting1.AddProperty(AmqpConstants.SimpleWebTokenPropertyName, this.relay.tokenRenewer.CurrentToken.Token);
}
if (!this.relay.TransportSecurityRequired)
{
amqpLinkSetting1.AddProperty(ClientConstants.TransportSecurityRequiredName, false);
}
if (!this.relay.RelayClientAuthorizationRequired)
{
amqpLinkSetting1.AddProperty(ClientConstants.ClientAuthenticationRequiredName, false);
}
if (this.relay.PublishToRegistry)
{
amqpLinkSetting1.AddProperty(ClientConstants.RequiresPublicRegistry, true);
}
if (!string.IsNullOrEmpty(this.relay.ClientAgent))
{
amqpLinkSetting1.AddProperty(ClientConstants.ClientAgent, this.relay.ClientAgent);
}
if (!string.IsNullOrEmpty(this.relay.DisplayName))
{
amqpLinkSetting1.AddProperty(ClientConstants.DisplayName, this.relay.DisplayName);
}
amqpLinkSetting1.AddProperty(ClientConstants.DynamicRelay, this.relay.IsDynamic);
amqpLinkSetting1.AddProperty(ClientConstants.ListenerTypeName, this.relay.ListenerType.ToString());
this.relay.link = new DuplexAmqpLink(amqpSession, amqpLinkSetting1);
yield return(base.CallTask(this.relay.link.OpenAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
this.relay.link.SafeAddClosed(this.relay.onAmqpObjectClosed);
this.relay.link.RegisterMessageListener((AmqpMessage msg) => this.relay.messageListener(this.relay.link, msg));
this.relay.OnOnline();
Label0:
yield break;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinationRelationshipViewModel"/> class.
/// </summary>
public DestinationRelationshipViewModel(RelationshipInfo relationshipInfo, ArcGISFeatureTable relatedTable, ConnectivityMode connectivityMode)
{
RelationshipInfo = relationshipInfo;
FeatureTable = relatedTable;
ConnectivityMode = connectivityMode;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinationRelationshipViewModel"/> class.
/// </summary>
public OriginRelationshipViewModel(RelationshipInfo relationshipInfo, ConnectivityMode connectivityMode)
{
RelationshipInfo = relationshipInfo;
ConnectivityMode = connectivityMode;
}
public NetEventRelayGatewayOperationServer(string serviceNamespace, string issuerName, string issuerKey, string servicePath, ConnectivityMode onewayConnectivityMode, Type serviceType, bool usePassword)
: base(serviceNamespace, issuerName, issuerKey, servicePath, onewayConnectivityMode, serviceType, usePassword)
{
}
/// <summary>
/// Connectivity mode used by Azure Service Bus.
/// <remarks>Default is ConnectivityMode.Tcp</remarks>
/// </summary>
public static void ConnectivityMode(this TransportExtensions <AzureServiceBusTransport> transportExtensions, ConnectivityMode connectivityMode)
{
var settings = transportExtensions.GetSettings();
settings.Set(WellKnownConfigurationKeys.Connectivity.ConnectivityMode, connectivityMode);
}
public ConnectivityConfig(ConnectivityMode algorithmType)
{
this.algorithmType = algorithmType;
Directed = algorithmType == ConnectivityMode.StronglyConnectedComponents;
}
public EditViewModel(ConnectivityMode connectivityMode)
{
ConnectivityMode = connectivityMode;
}
public static int VerifyListen(string connectionString, string path, Binding binding, ConnectivityMode connectivityMode, string response, ServiceThrottlingBehavior throttlingBehavior)
{
RelayTraceSource.TraceInfo($"Open relay listener using {binding.GetType().Name}, ConnectivityMode.{connectivityMode}...");
ServiceHost serviceHost = null;
try
{
var connectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString);
var tp = TokenProvider.CreateSharedAccessSignatureTokenProvider(connectionStringBuilder.SharedAccessKeyName, connectionStringBuilder.SharedAccessKey);
string relayNamespace = connectionStringBuilder.Endpoints.First().Host;
ServiceBusEnvironment.SystemConnectivity.Mode = connectivityMode;
EchoService.DefaultResponse = response;
if (!(binding is WebHttpRelayBinding))
{
serviceHost = new ServiceHost(typeof(EchoService));
}
else
{
serviceHost = new WebServiceHost(typeof(EchoService));
}
Type contractType = IsOneWay(binding) ? typeof(ITestOneway) : typeof(IEcho);
ServiceEndpoint endpoint = serviceHost.AddServiceEndpoint(contractType, binding, new Uri($"{binding.Scheme}://{relayNamespace}/{path}"));
var listenerActivityId = Guid.NewGuid();
RelayTraceSource.TraceVerbose($"Listener ActivityId:{listenerActivityId}");
endpoint.EndpointBehaviors.Add(new TransportClientEndpointBehavior(tp)
{
ActivityId = listenerActivityId
});
serviceHost.Description.Behaviors.Add(throttlingBehavior);
// Trace status changes
var connectionStatus = new ConnectionStatusBehavior();
connectionStatus.Connecting += (s, e) => RelayTraceSource.TraceException(connectionStatus.LastError, TraceEventType.Warning, "Relay listener Re-Connecting");
connectionStatus.Online += (s, e) => RelayTraceSource.Instance.TraceEvent(TraceEventType.Information, (int)ConsoleColor.Green, "Relay Listener is online");
EventHandler offlineHandler = (s, e) => RelayTraceSource.TraceException(connectionStatus.LastError, "Relay Listener is OFFLINE");
connectionStatus.Offline += offlineHandler;
endpoint.EndpointBehaviors.Add(connectionStatus);
serviceHost.Faulted += (s, e) => RelayTraceSource.TraceException(connectionStatus.LastError, "Relay listener ServiceHost Faulted");
serviceHost.Open();
RelayTraceSource.TraceInfo("Relay listener \"" + endpoint.Address.Uri + "\" is open");
RelayTraceSource.TraceInfo("Press <ENTER> to close the listener ");
Console.ReadLine();
RelayTraceSource.TraceInfo("Closing Connection...");
connectionStatus.Offline -= offlineHandler; // Avoid a spurious trace on expected shutdown.
serviceHost.Close();
RelayTraceSource.TraceInfo("Closed");
return(0);
}
catch (Exception)
{
serviceHost?.Abort();
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinationRelationshipViewModel"/> class.
/// </summary>
public OriginRelationshipViewModel(ArcGISFeatureTable relatedTable, ConnectivityMode connectivityMode)
{
RelatedTable = relatedTable;
ConnectivityMode = connectivityMode;
}
private void InitBindingInCode(string solutionName, string solutionPassword, string servicePath, ConnectivityMode onewayConnectivityMode, Type serviceType)
{
//ServiceBusEnvironment.OnewayConnectivity.Mode = onewayConnectivityMode;
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", solutionName, servicePath);
ServiceUri = address.ToString();
Host = new ServiceHost(serviceType, address);
ContractDescription contractDescription = ContractDescription.GetContract(typeof(IOnewayEnergyServiceOperations), typeof(OnewayEnergyServiceOperations));
ServiceEndpoint serviceEndPoint = new ServiceEndpoint(contractDescription);
serviceEndPoint.Address = new EndpointAddress(ServiceUri);
serviceEndPoint.Binding = new NetOnewayRelayBinding();
TransportClientEndpointBehavior behavior = ServiceBusHelper.GetUsernamePasswordBehavior(solutionName, solutionPassword);
serviceEndPoint.Behaviors.Add(behavior);
Host.Description.Endpoints.Add(serviceEndPoint);
ServiceRegistrySettings settings = new ServiceRegistrySettings();
settings.DiscoveryMode = DiscoveryType.Public;
settings.DisplayName = address.ToString();
foreach (ServiceEndpoint se in Host.Description.Endpoints)
{
se.Behaviors.Add(settings);
}
Host.Open();
}
//typeof(OnewayEnergyServiceOperations)
private void InitService(string serviceNamespace, string issuerName, string issuerKey, string servicePath, ConnectivityMode onewayConnectivityMode, Type serviceType, bool usePassword)
{
ServiceBusEnvironment.SystemConnectivity.Mode = onewayConnectivityMode;
// Host = new ServiceHost(serviceType, address);
Host = new ServiceHost(serviceType);
if (usePassword)
{
TransportClientEndpointBehavior behavior = ServiceBusHelper.GetUsernamePasswordBehavior(issuerName, issuerKey);
Host.Description.Endpoints[0].Behaviors.Add(behavior);
}
ServiceUri = Host.Description.Endpoints[0].ListenUri.ToString();
ServiceRegistrySettings settings = new ServiceRegistrySettings();
settings.DiscoveryMode = DiscoveryType.Public;
settings.DisplayName = ServiceUri;
foreach (ServiceEndpoint se in Host.Description.Endpoints)
{
se.Behaviors.Add(settings);
}
Host.Open();
}
public NetOnewayEnergyServiceOperationsServer(string serviceNamespace, string issuerName, string issuerKey, string servicePath, ConnectivityMode onewayConnectivityMode, Type serviceType, bool usePassword)
{
InitService(serviceNamespace, issuerName, issuerKey, servicePath, onewayConnectivityMode, serviceType, usePassword);
}
public static int VerifySend(
string request, ServiceBusConnectionStringBuilder connectionString, string path, int number, Binding binding, bool noClientAuth, ConnectivityMode connectivityMode, TimeSpan requestDelay)
{
RelayTraceSource.TraceInfo($"Send to relay listener using {binding.GetType().Name}, ConnectivityMode.{connectivityMode}...");
string relayNamespace = connectionString.Endpoints.First().Host;
string keyName = connectionString.SharedAccessKeyName;
string keyValue = connectionString.SharedAccessKey;
if (IsOneWay(binding))
{
return(VerifySendCore <ITestOnewayClient>(request, relayNamespace, path, number, binding, noClientAuth, connectivityMode, keyName, keyValue, requestDelay));
}
else
{
return(VerifySendCore <IEchoClient>(request, relayNamespace, path, number, binding, noClientAuth, connectivityMode, keyName, keyValue, requestDelay));
}
}
static int VerifySendCore <TChannel>(
string request, string relayNamespace, string path, int number, Binding binding, bool noClientAuth, ConnectivityMode connectivityMode, string keyName, string keyValue, TimeSpan requestDelay)
where TChannel : class, IClientChannel
{
ChannelFactory <TChannel> channelFactory = null;
TChannel channel = null;
try
{
ServiceBusEnvironment.SystemConnectivity.Mode = connectivityMode;
Uri address = new Uri($"{binding.Scheme}://{relayNamespace}/{path}");
if (binding is WebHttpRelayBinding)
{
channelFactory = new WebChannelFactory <TChannel>(binding, address);
}
else
{
channelFactory = new ChannelFactory <TChannel>(binding, new EndpointAddress(address));
}
var tp = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, keyValue);
if (!noClientAuth)
{
channelFactory.Endpoint.EndpointBehaviors.Add(new TransportClientEndpointBehavior(tp));
}
RelayTraceSource.TraceVerbose("Sender opening channel factory");
var stopwatch = new Stopwatch();
stopwatch.Restart();
channelFactory.Open();
RelayTraceSource.TraceVerbose($"Sender opened channel factory in {stopwatch.ElapsedMilliseconds} ms");
channel = channelFactory.CreateChannel();
RelayTraceSource.TraceInfo("Sender opening channel");
using (new OperationContextScope(channel))
{
Guid trackingId = Guid.NewGuid();
RelayTraceSource.TraceVerbose($"Channel TrackingId:{trackingId}");
if (binding.MessageVersion.Addressing != AddressingVersion.None)
{
OperationContext.Current.OutgoingMessageHeaders.MessageId = new UniqueId(trackingId);
}
stopwatch.Restart();
channel.Open();
RelayTraceSource.TraceVerbose($"Sender opened channel in {stopwatch.ElapsedMilliseconds} ms");
RelayTraceSource.TraceVerbose($"Channel SessionId:{channel.SessionId}");
}
for (int i = 0; i < number; i++)
{
using (new OperationContextScope(channel))
{
var messageId = Guid.NewGuid();
RelayTraceSource.TraceVerbose($"Sending MessageId:{messageId}");
if (binding.MessageVersion.Addressing != AddressingVersion.None)
{
OperationContext.Current.OutgoingMessageHeaders.MessageId = new UniqueId(messageId);
}
stopwatch.Restart();
if (channel is IEchoClient echoChannel)
{
string response = echoChannel.Echo(DateTime.UtcNow, request, requestDelay);
RelayTraceSource.TraceInfo($"Sender received response: {response} ({stopwatch.ElapsedMilliseconds} ms)");
}
else if (channel is ITestOnewayClient onewayClient)
{
onewayClient.Operation(DateTime.UtcNow, request);
RelayTraceSource.TraceInfo($"Sender sent oneway request: {request} ({stopwatch.ElapsedMilliseconds} ms)");
}
else
{
throw new NotSupportedException($"Contract {typeof(TChannel)} is not supported");
}
}
}
RelayTraceSource.TraceInfo("Sender closing channel");
stopwatch.Restart();
channel.Close();
RelayTraceSource.TraceVerbose($"Sender closed channel in {stopwatch.ElapsedMilliseconds} ms");
channel = null;
RelayTraceSource.TraceVerbose("Sender closing channel factory");
stopwatch.Restart();
channelFactory.Close();
RelayTraceSource.TraceVerbose($"Sender closed channel factory in {stopwatch.ElapsedMilliseconds} ms");
channelFactory = null;
return(0);
}
finally
{
channel?.Abort();
channelFactory?.Abort();
}
}
