public async Task Run(string serviceBusHostName, string sendToken) { var sendAddress = new UriBuilder("sb", serviceBusHostName, -1, "hybridconnect").ToString(); var binding = new NetTcpRelayBinding(EndToEndSecurityMode.None, RelayClientAuthenticationType.RelayAccessToken) { ConnectionMode = TcpRelayConnectionMode.Hybrid }; var cf = new ChannelFactory <IClient>(binding, sendAddress); cf.Endpoint.EndpointBehaviors.Add( new TransportClientEndpointBehavior( TokenProvider.CreateSharedAccessSignatureTokenProvider(sendToken))); using (var client = cf.CreateChannel()) { var sw = Stopwatch.StartNew(); for (int i = 1; i <= 1000; i++) { sw.Restart(); var result = await client.Echo(DateTime.UtcNow.ToString()); Console.WriteLine("Round {0}, Echo: {1}, Latency {2}ms", i, result, sw.ElapsedMilliseconds); } client.Close(); } Console.WriteLine("Press [Enter] to exit."); Console.ReadLine(); }
private static void RunService() { Console.WriteLine("Server"); ServiceRegistrySettings registryBehavior = new ServiceRegistrySettings() { DiscoveryMode = DiscoveryType.Public, DisplayName = "Temperature Service" }; TransportClientEndpointBehavior credentialBehavior = new TransportClientEndpointBehavior(); credentialBehavior.CredentialType = TransportClientCredentialType.SharedSecret; credentialBehavior.Credentials.SharedSecret.IssuerName = issuerName; credentialBehavior.Credentials.SharedSecret.IssuerSecret = issuerKey; Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, serviceName); using (ServiceHost serviceHost = new ServiceHost(typeof(TemperatureService), serviceUri)) { NetTcpRelayBinding binding = new NetTcpRelayBinding(); serviceHost.AddServiceEndpoint(typeof(ITemperatureContract), binding, serviceUri); serviceHost.Description.Endpoints[0].Behaviors.Add(credentialBehavior); serviceHost.Description.Endpoints[0].Behaviors.Add(registryBehavior); serviceHost.Open(); Console.WriteLine("Press Enter to exit."); Console.ReadLine(); } }
internal static void AddServiceBusDefaultEndpoints(this ServiceHost host,Uri[] baseAddresses) { Debug.Assert(baseAddresses.Any(address=>address.Scheme == "sb")); Type[] contracts = GetServiceContracts(host.Description.ServiceType); Binding binding = new NetTcpRelayBinding(); foreach(Uri baseAddress in baseAddresses) { if(baseAddress.Scheme != "sb") { continue; } foreach(Type contract in contracts) { string address = baseAddress.AbsoluteUri; if(address.EndsWith("/") == false) { address += "/"; } address += contract.Name; host.AddServiceEndpoint(contract,binding,address); } } }
internal static void AddServiceBusDefaultEndpoints(this ServiceHost host, Uri[] baseAddresses) { Debug.Assert(baseAddresses.Any(address => address.Scheme == "sb")); Type[] contracts = GetServiceContracts(host.Description.ServiceType); Binding binding = new NetTcpRelayBinding(); foreach (Uri baseAddress in baseAddresses) { if (baseAddress.Scheme != "sb") { continue; } foreach (Type contract in contracts) { string address = baseAddress.AbsoluteUri; if (address.EndsWith("/") == false) { address += "/"; } address += contract.Name; host.AddServiceEndpoint(contract, binding, address); } } }
public static ChannelFactory <T> CreateServiceBusClientChannelFactory <T>(ServiceBusEndpointInfo sbEndpointInfo) where T : IClientChannel { Guard.ArgumentNotNull(sbEndpointInfo, "sbEndpointInfo"); Binding binding = null; switch (sbEndpointInfo.EndpointType) { case ServiceBusEndpointType.Eventing: binding = new NetEventRelayBinding(EndToEndSecurityMode.None, RelayEventSubscriberAuthenticationType.None); break; case ServiceBusEndpointType.Relay: case ServiceBusEndpointType.HybridRelay: NetTcpRelayBinding tcpRelayBinding = new NetTcpRelayBinding(EndToEndSecurityMode.None, RelayClientAuthenticationType.None); tcpRelayBinding.ConnectionMode = (sbEndpointInfo.EndpointType == ServiceBusEndpointType.HybridRelay ? TcpRelayConnectionMode.Hybrid : TcpRelayConnectionMode.Relayed); binding = tcpRelayBinding; break; default: return(null); } return(CreateServiceBusClientChannelFactory <T>(sbEndpointInfo.ServiceNamespace, sbEndpointInfo.ServicePath, sbEndpointInfo.IssuerName, sbEndpointInfo.IssuerSecret, binding)); }
public async Task Run(string serviceBusHostName, string sendToken) { var sendAddress = new UriBuilder("sb", serviceBusHostName, -1, "hybridconnect").ToString(); var binding = new NetTcpRelayBinding(EndToEndSecurityMode.None, RelayClientAuthenticationType.RelayAccessToken) { ConnectionMode = TcpRelayConnectionMode.Hybrid }; var cf = new ChannelFactory<IClient>(binding,sendAddress); cf.Endpoint.EndpointBehaviors.Add( new TransportClientEndpointBehavior( TokenProvider.CreateSharedAccessSignatureTokenProvider(sendToken))); using (var client = cf.CreateChannel()) { var sw = Stopwatch.StartNew(); for (int i = 1; i <= 1000; i++) { sw.Restart(); var result = await client.Echo(DateTime.UtcNow.ToString()); Console.WriteLine("Round {0}, Echo: {1}, Latency {2}ms", i, result, sw.ElapsedMilliseconds); } client.Close(); } Console.WriteLine("Press [Enter] to exit."); Console.ReadLine(); }
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress, Binding binding, string issuer, string secret) { Binding extendedBinding = null; if (binding is NetTcpRelayBinding) { NetTcpRelayBinding actualBinding = binding as NetTcpRelayBinding; actualBinding.MaxReceivedMessageSize *= MessageSizeMultiplier; extendedBinding = actualBinding; } if (binding is WS2007HttpRelayBinding) { WS2007HttpRelayBinding actualBinding = binding as WS2007HttpRelayBinding; actualBinding.MaxReceivedMessageSize *= MessageSizeMultiplier; extendedBinding = actualBinding; } MetadataExchangeClient mexClient = new MetadataExchangeClient(extendedBinding); mexClient.SetServiceBusCredentials(issuer, secret); MetadataSet metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress)); MetadataImporter importer = new WsdlImporter(metadata); return(importer.ImportAllEndpoints()); }
public async Task Run(string serviceBusHostName, string listenToken) { var listenAddress = new UriBuilder("sb", serviceBusHostName, -1, "hybridconnect").ToString(); using (ServiceHost host = new ServiceHost(this)) { var binding = new NetTcpRelayBinding(EndToEndSecurityMode.None, RelayClientAuthenticationType.RelayAccessToken) { ConnectionMode = TcpRelayConnectionMode.Hybrid }; host.AddServiceEndpoint( GetType(), binding, listenAddress) .EndpointBehaviors.Add( new TransportClientEndpointBehavior( TokenProvider.CreateSharedAccessSignatureTokenProvider(listenToken))); host.Open(); Console.WriteLine("Service listening at address {0}", listenAddress); Console.WriteLine("Press [Enter] to close the listener and exit."); Console.ReadLine(); host.Close(); } }
private static void RunClient() { Console.WriteLine("Client"); TransportClientEndpointBehavior credentialBehavior = new TransportClientEndpointBehavior(); credentialBehavior.CredentialType = TransportClientCredentialType.SharedSecret; credentialBehavior.Credentials.SharedSecret.IssuerName = issuerName; credentialBehavior.Credentials.SharedSecret.IssuerSecret = issuerKey; NetTcpRelayBinding binding = new NetTcpRelayBinding(); Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, serviceName); EndpointAddress endpointAddress = new EndpointAddress(serviceUri); using (ChannelFactory<ITemperatureContract> channelFactory = new ChannelFactory<ITemperatureContract>(binding, endpointAddress)) { channelFactory.Endpoint.Behaviors.Add(credentialBehavior); ITemperatureContract channel = channelFactory.CreateChannel(); ((ICommunicationObject)channel).Open(); Double boilingPointCelsius = channel.ToCelsius(212); Double boilingPointFahrenheit = channel.ToFahrenheit(boilingPointCelsius); Console.WriteLine("212 Fahrenheit is {0} Celsius", boilingPointCelsius); Console.WriteLine("{0} Celsius is {1} Fahrenheit", boilingPointCelsius, boilingPointFahrenheit); ((ICommunicationObject)channel).Close(); Console.WriteLine("Press Enter to exit."); Console.ReadLine(); } }
/// <summary> /// Installs an event dispatcher that can be contacted from anywhere /// </summary> public static void UseAzureServiceBusRelayEventDispatcher(this EventDispatcherConfigurationBuilder builder, string serviceNamespace, string servicePath, string keyName, string sharesAccessKey, NetTcpRelayBinding netTcpRelayBinding = null) { builder.UseEventDispatcher(context => { var eventStore = context.Get<IEventStore>(); return new AzureServiceBusRelayEventDispatcher(eventStore, serviceNamespace, servicePath, keyName, sharesAccessKey, netTcpRelayBinding); }); }
public NamedPipeClientConnectionForwarder(string serviceNamespace, string issuerName, string issuerSecret, string targetHost, string localPipe, string toPipe, bool useHybrid) { this.toPipe = toPipe; this.localPipe = localPipe; this.connections = new Dictionary<int, MultiplexedPipeConnection>(); this.endpointVia = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Format("/PortBridge/{0}", targetHost)); this.streamBinding = CreateClientBinding(useHybrid); this.relayCreds = new TransportClientEndpointBehavior(); this.relayCreds.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret); }
NetTcpRelayBinding CreateClientBinding(bool useHybrid) { NetTcpRelayBinding clientBinding = new NetTcpRelayBinding(useHybrid ? EndToEndSecurityMode.None : EndToEndSecurityMode.Transport, RelayClientAuthenticationType.RelayAccessToken); clientBinding.TransferMode = TransferMode.Buffered; clientBinding.MaxReceivedMessageSize = 1024 * 1024; clientBinding.MaxBufferSize = 1024 * 1024; clientBinding.SendTimeout = TimeSpan.FromSeconds(120); clientBinding.ReceiveTimeout = TimeSpan.FromHours(1); clientBinding.ConnectionMode = useHybrid ? TcpRelayConnectionMode.Hybrid : TcpRelayConnectionMode.Relayed; return(clientBinding); }
internal static void ConfigureBinding(Binding binding, bool anonymous = true) { if (binding is NetTcpRelayBinding) { NetTcpRelayBinding tcpBinding = (NetTcpRelayBinding)binding; tcpBinding.Security.Mode = EndToEndSecurityMode.Message; if (anonymous) { tcpBinding.Security.Message.ClientCredentialType = MessageCredentialType.None; } else { tcpBinding.Security.Message.ClientCredentialType = MessageCredentialType.UserName; } tcpBinding.ConnectionMode = TcpRelayConnectionMode.Hybrid; tcpBinding.ReliableSession.Enabled = true; return; } if (binding is WSHttpRelayBinding) { WSHttpRelayBinding wsBinding = (WSHttpRelayBinding)binding; wsBinding.Security.Mode = EndToEndSecurityMode.Message; if (anonymous) { wsBinding.Security.Message.ClientCredentialType = MessageCredentialType.None; } else { wsBinding.Security.Message.ClientCredentialType = MessageCredentialType.UserName; } wsBinding.ReliableSession.Enabled = true; return; } if (binding is NetOnewayRelayBinding) { NetOnewayRelayBinding onewayBinding = (NetOnewayRelayBinding)binding; onewayBinding.Security.Mode = EndToEndSecurityMode.Message; if (anonymous) { onewayBinding.Security.Message.ClientCredentialType = MessageCredentialType.None; } else { onewayBinding.Security.Message.ClientCredentialType = MessageCredentialType.UserName; } return; } throw new InvalidOperationException(binding.GetType() + " is unsupported"); }
protected override void OnStart(string[] args) { var setupLocalService = _kernel.Get <ISetupLocalService>(); var settingServerName = setupLocalService.Find("PrintServiceServerName"); var serverName = "localhost"; // settingServerName != null ? settingServerName.SetupValueNvarchar : "localhost"; var settingServerPort = setupLocalService.Find("PrintServiceServerPort"); var serverPort = settingServerPort != null ? settingServerPort.SetupValueInt : 49501; _serviceHost = new ServiceHost(typeof(PrintService)); var binding = new NetTcpBinding { TransferMode = TransferMode.Buffered, MaxBufferPoolSize = 2147483647, MaxBufferSize = 2147483647, MaxReceivedMessageSize = 2147483647 }; _serviceHost.AddServiceEndpoint( typeof(IPrintService), binding, string.Format("net.tcp://{0}:{1}/print", serverName, serverPort)); var settingRelayServiceName = setupLocalService.Find("RelayServiceName"); var serviceNamespace = settingRelayServiceName != null ? settingRelayServiceName.SetupValueNvarchar : null; var settingRelayServiceSecret = setupLocalService.Find("RelayServiceSecret"); var serviceSecret = settingRelayServiceSecret != null ? settingRelayServiceSecret.SetupValueNvarchar : null; if (!string.IsNullOrEmpty(serviceNamespace) && !string.IsNullOrEmpty(serviceSecret)) { var relayBinding = new NetTcpRelayBinding { TransferMode = TransferMode.Buffered, MaxBufferPoolSize = 2147483647, MaxBufferSize = 2147483647, MaxReceivedMessageSize = 2147483647 }; _serviceHost.AddServiceEndpoint( typeof(IPrintService), relayBinding, ServiceBusEnvironment .CreateServiceUri("sb", serviceNamespace, "print")) .Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider .CreateSharedSecretTokenProvider( "owner", serviceSecret ) }); } _serviceHost.Open(); }
public AzureServiceBusRelayEventStoreProxy(string serviceNamespace, string servicePath, string keyName, string sharedAccessKey, NetTcpRelayBinding netTcpRelayBinding = null) { var uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, servicePath); _logger.Info("Initializing event store facade for {0}", uri); var binding = netTcpRelayBinding ?? BindingHelper.CreateDefaultRelayBinding(); _channelFactory = new ChannelFactory<IHostService>(binding, new EndpointAddress(uri)); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, sharedAccessKey); var endpointBehavior = new TransportClientEndpointBehavior(tokenProvider); _channelFactory.Endpoint.Behaviors.Add(endpointBehavior); }
public NamedPipeClientConnectionForwarder(string serviceNamespace, string issuerName, string issuerSecret, string targetHost, string localPipe, string toPipe, bool useHybrid) { this.toPipe = toPipe; this.localPipe = localPipe; this.connections = new Dictionary <int, MultiplexedPipeConnection>(); this.endpointVia = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Format("/PortBridge/{0}", targetHost)); this.streamBinding = CreateClientBinding(useHybrid); /*this.relayCreds = new TransportClientEndpointBehavior(); * this.relayCreds.CredentialType = TransportClientCredentialType.SharedSecret; * this.relayCreds.Credentials.SharedSecret.IssuerName = issuerName; * this.relayCreds.Credentials.SharedSecret.IssuerSecret = issuerSecret;*/ }
public AzureServiceBusRelayEventDispatcher(IEventStore eventStore, string serviceNamespace, string path, string keyName, string sharedAccessKey, NetTcpRelayBinding netTcpRelayBinding = null) { var uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, path); _logger.Info("Initializing service bus relay host for {0}", uri); _serviceHost = new ServiceHost(new HostService(eventStore)); var binding = netTcpRelayBinding ?? BindingHelper.CreateDefaultRelayBinding(); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, sharedAccessKey); var endpoint = _serviceHost.AddServiceEndpoint(typeof(IHostService), binding, uri); var endpointBehavior = new TransportClientEndpointBehavior(tokenProvider); endpoint.Behaviors.Add(endpointBehavior); }
public TcpClientConnectionForwarder(string serviceNamespace, string issuerName, string issuerSecret, string targetHost, int fromPort, int toPort, string bindTo, bool useHybrid, IEnumerable <IPRange> firewallRules) { this.toPort = toPort; this.fromPort = fromPort; this.bindTo = bindTo; this.firewallRules = firewallRules; this.connections = new Dictionary <int, MultiplexedTcpConnection>(); this.endpointVia = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Format("/PortBridge/{0}", targetHost)); this.streamBinding = CreateClientBinding(useHybrid); /*this.relayCreds = new TransportClientEndpointBehavior(); * this.relayCreds.CredentialType = TransportClientCredentialType.SharedSecret; * this.relayCreds.Credentials.SharedSecret.IssuerName = issuerName; * this.relayCreds.Credentials.SharedSecret.IssuerSecret = issuerSecret;*/ }
public TcpClientConnectionForwarder(string serviceNamespace, string issuerName, string issuerSecret, string targetHost, int fromPort, int toPort, string bindTo, bool useHybrid, IEnumerable<IPRange> firewallRules) { this.toPort = toPort; this.fromPort = fromPort; this.bindTo = bindTo; this.firewallRules = firewallRules; this.connections = new Dictionary<int, MultiplexedTcpConnection>(); this.endpointVia = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Format("/PortBridge/{0}", targetHost)); this.streamBinding = CreateClientBinding(useHybrid); this.relayCreds = new TransportClientEndpointBehavior(); this.relayCreds.CredentialType = TransportClientCredentialType.SharedSecret; this.relayCreds.Credentials.SharedSecret.IssuerName = issuerName; this.relayCreds.Credentials.SharedSecret.IssuerSecret = issuerSecret; }
protected override void InitializeFrom(Binding binding) { base.InitializeFrom(binding); NetTcpRelayBinding netTcpRelayBinding = (NetTcpRelayBinding)binding; this.ConnectionMode = netTcpRelayBinding.ConnectionMode; this.TransferMode = netTcpRelayBinding.TransferMode; this.MaxBufferPoolSize = netTcpRelayBinding.MaxBufferPoolSize; this.MaxBufferSize = netTcpRelayBinding.MaxBufferSize; this.MaxConnections = netTcpRelayBinding.MaxConnections; this.MaxReceivedMessageSize = netTcpRelayBinding.MaxReceivedMessageSize; this.ListenBacklog = netTcpRelayBinding.ListenBacklog; this.ReliableSession.InitializeFrom(netTcpRelayBinding.ReliableSession); this.Security.InitializeFrom(netTcpRelayBinding.Security); this.ReaderQuotas.InitializeFrom(netTcpRelayBinding.ReaderQuotas); this.IsDynamic = netTcpRelayBinding.IsDynamic; }
/// <summary> /// Extends the OnStart phase that is called by Windows Azure runtime to initialize the role instance. /// </summary> /// <returns>True if initialization succeeds, otherwise false.</returns> protected override bool OnRoleStart() { this.EnsureExists <ScalableTransformConfigurationExtension>(); this.EnsureExists <CloudStorageProviderExtension>(); this.EnsureExists <XslTransformMetadataProviderExtension>(); this.EnsureExists <XslTransformInProcCacheExtension>(); this.EnsureExists <XslTransformProviderExtension>(); this.EnsureExists <EndpointConfigurationDiscoveryExtension>(); IEndpointConfigurationDiscoveryExtension discoveryExtension = Extensions.Find <IEndpointConfigurationDiscoveryExtension>(); IRoleConfigurationSettingsExtension roleConfigExtension = Extensions.Find <IRoleConfigurationSettingsExtension>(); IScalableTransformConfigurationExtension serviceConfigExtension = Extensions.Find <IScalableTransformConfigurationExtension>(); StorageAccountConfigurationSettings storageSettings = roleConfigExtension.GetSection <StorageAccountConfigurationSettings>(StorageAccountConfigurationSettings.SectionName); XslTransformCloudBlobCacheExtension cloudBlobCache = new XslTransformCloudBlobCacheExtension(storageSettings.Accounts.Get(serviceConfigExtension.Settings.CacheStorageAccount)); CloudStorageLoadBalancingExtension storageLoadBalancer = new CloudStorageLoadBalancingExtension(from name in serviceConfigExtension.Settings.StorageAccounts.AllKeys select storageSettings.Accounts.Get(name)); // Configure the cache TTL for the blob caching extension. cloudBlobCache.CacheTimeToLive = serviceConfigExtension.Settings.BlobCacheTimeToLive; // Configure the cache TTL for the in-proc caching extension. XslTransformInProcCacheExtension memoryCache = Extensions.Find <XslTransformInProcCacheExtension>(); memoryCache.CacheTimeToLive = serviceConfigExtension.Settings.MemoryCacheTimeToLive; Extensions.Add(cloudBlobCache); Extensions.Add(storageLoadBalancer); // Done with configuring all infrastructure extensions, now proceed with registering the service extension that implements the core methods. this.EnsureExists <ScalableTransformServiceExtension>(); var contractTypeMatchCondition = ServiceEndpointDiscoveryCondition.ContractTypeExactMatch(typeof(IScalableTransformationServiceContract)); var bindingTypeMatchCondition = ServiceEndpointDiscoveryCondition.BindingTypeExactMatch(typeof(NetTcpRelayBinding)); discoveryExtension.RegisterDiscoveryAction(new[] { contractTypeMatchCondition, bindingTypeMatchCondition }, (endpoint) => { NetTcpRelayBinding relayBinding = endpoint.Binding as NetTcpRelayBinding; if (relayBinding != null) { relayBinding.TransferMode = TransferMode.Streamed; } }); return(true); }
void ConfigureProtectionLevel(Binding binding) { m_NonProtectionRadioButton.Checked = false; m_SignedRadioButton.Checked = false; m_EncryptRadioButton.Checked = false; m_NonProtectionRadioButton.Enabled = false; m_SignedRadioButton.Enabled = false; m_EncryptRadioButton.Enabled = false; if (binding is NetTcpBinding) { NetTcpBinding tcpBinding = binding as NetTcpBinding; if (tcpBinding.Security.Mode == SecurityMode.Transport) { SetProtectionLevel(tcpBinding.Security.Transport.ProtectionLevel); } } if (binding is NetNamedPipeBinding) { NetNamedPipeBinding pipeBinding = binding as NetNamedPipeBinding; if (pipeBinding.Security.Mode == NetNamedPipeSecurityMode.Transport) { SetProtectionLevel(pipeBinding.Security.Transport.ProtectionLevel); } } if (binding is NetMsmqBinding) { NetMsmqBinding msmqBinding = binding as NetMsmqBinding; if (msmqBinding.Security.Mode == NetMsmqSecurityMode.Transport || msmqBinding.Security.Mode == NetMsmqSecurityMode.Both) { SetProtectionLevel(msmqBinding.Security.Transport.MsmqProtectionLevel); } } if (binding is NetTcpRelayBinding) { NetTcpRelayBinding tcpRealyBinding = binding as NetTcpRelayBinding; if (tcpRealyBinding.Security.Mode == EndToEndSecurityMode.Transport) { SetProtectionLevel(tcpRealyBinding.Security.Transport.ProtectionLevel); } } }
private void StartSignallingWorker(ServiceBusSignalingListenerEndpointSettings signallingEndpointSettings) { Uri signallingURI; ServiceHost host; ServiceEndpoint endpoint; TokenProvider tokenProvider; TransportClientEndpointBehavior transportClientEndpointBehavior; string address = string.Format("{0}://{1}.{2}/{3}", signallingEndpointSettings.Scheme, signallingEndpointSettings.Namespace, signallingEndpointSettings.Domain, signallingEndpointSettings.ServicePath ); if (!Uri.TryCreate(address, UriKind.Absolute, out signallingURI)) { throw new BootstrapException(String.Format("Could not parse provided signalling URI: {0}", address)); } Binding binding = new NetTcpRelayBinding { IsDynamic = false, HostNameComparisonMode = HostNameComparisonMode.Exact }; ConnectionStatusBehavior statusBehavior = new ConnectionStatusBehavior(); statusBehavior.Online += delegate(object o, EventArgs e) { Console.WriteLine("[:)] Listener for is now online."); }; host = new ServiceHost(typeof(ConnectorSignalingService), signallingURI); tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(signallingEndpointSettings.SharedAccessKeyName, signallingEndpointSettings.SharedAccessKey); endpoint = host.AddServiceEndpoint(typeof(IConnectorSignalingService), binding, address); transportClientEndpointBehavior = new TransportClientEndpointBehavior(tokenProvider); endpoint.EndpointBehaviors.Add(statusBehavior); endpoint.EndpointBehaviors.Add(transportClientEndpointBehavior); host.Open(); }
protected override void OnApplyConfiguration(Binding binding) { NetTcpRelayBinding transferMode = (NetTcpRelayBinding)binding; transferMode.TransferMode = this.TransferMode; transferMode.ConnectionMode = this.ConnectionMode; transferMode.ListenBacklog = this.ListenBacklog; transferMode.MaxBufferPoolSize = this.MaxBufferPoolSize; if (base.ElementInformation.Properties["maxBufferSize"].ValueOrigin != PropertyValueOrigin.Default) { transferMode.MaxBufferSize = this.MaxBufferSize; } transferMode.MaxConnections = this.MaxConnections; transferMode.MaxReceivedMessageSize = this.MaxReceivedMessageSize; this.ReliableSession.ApplyConfiguration(transferMode.ReliableSession); this.Security.ApplyConfiguration(transferMode.Security); this.ReaderQuotas.ApplyConfiguration(transferMode.ReaderQuotas); transferMode.IsDynamic = this.IsDynamic; }
/// <summary> /// Extends the OnStart phase that is called by Windows Azure runtime to initialize the role instance. /// </summary> /// <returns>True if initialization succeeds, otherwise false.</returns> protected override bool OnRoleStart() { this.EnsureExists <EndpointConfigurationDiscoveryExtension>(); this.EnsureExists <ActivityTrackingEventStreamExtension>(); IEndpointConfigurationDiscoveryExtension discoveryExtension = Extensions.Find <IEndpointConfigurationDiscoveryExtension>(); var contractTypeMatchCondition = ServiceEndpointDiscoveryCondition.ContractTypeExactMatch(typeof(IPersistenceServiceContract)); var bindingTypeMatchCondition = ServiceEndpointDiscoveryCondition.BindingTypeExactMatch(typeof(NetTcpRelayBinding)); discoveryExtension.RegisterDiscoveryAction(new [] { contractTypeMatchCondition, bindingTypeMatchCondition }, (endpoint) => { NetTcpRelayBinding relayBinding = endpoint.Binding as NetTcpRelayBinding; if (relayBinding != null) { relayBinding.TransferMode = TransferMode.Streamed; } }); return(true); }
/// <summary> /// Configures default settings for the specified <see cref="Microsoft.ServiceBus.NetTcpRelayBinding"/> binding. /// </summary> /// <param name="relayBinding">The Service Bus transport binding to be configured.</param> public static void ConfigureDefaults(NetTcpRelayBinding relayBinding) { Guard.ArgumentNotNull(relayBinding, "relayBinding"); relayBinding.TransferMode = DefaultTransferMode; relayBinding.ConnectionMode = DefaultRelayConnectionMode; relayBinding.OpenTimeout = TimeSpan.FromSeconds(DefaultOpenTimeoutSeconds); relayBinding.CloseTimeout = TimeSpan.FromSeconds(DefaultCloseTimeoutSeconds); relayBinding.ReceiveTimeout = TimeSpan.FromSeconds(DefaultReceiveTimeoutSeconds); relayBinding.SendTimeout = TimeSpan.FromSeconds(DefaultSendTimeoutSeconds); relayBinding.MaxReceivedMessageSize = DefaultMaxReceivedMessageSize; relayBinding.MaxBufferPoolSize = DefaultMaxBufferPoolSize; relayBinding.MaxBufferSize = DefaultMaxBufferSize; relayBinding.ReaderQuotas.MaxArrayLength = DefaultReaderQuotasMaxArrayLength; relayBinding.ReaderQuotas.MaxBytesPerRead = DefaultReaderQuotasMaxBytesPerRead; relayBinding.ReaderQuotas.MaxDepth = DefaultReaderQuotasMaxDepth; relayBinding.ReaderQuotas.MaxNameTableCharCount = DefaultReaderQuotasMaxNameTableCharCount; relayBinding.ReaderQuotas.MaxStringContentLength = DefaultReaderQuotasMaxStringContentLength; }
public static ServiceEndpoint[] GetEndpoints(string mexAddress,TokenProvider tokenProvider) { if(string.IsNullOrWhiteSpace(mexAddress)) { throw new ArgumentException("mexAddress"); } Uri address = new Uri(mexAddress); ServiceEndpointCollection endpoints = null; Binding binding; if(address.Scheme == "sb") { binding = new NetTcpRelayBinding(); } else { Debug.Assert(address.Scheme == "http" || address.Scheme == "https"); binding = new WS2007HttpRelayBinding(); } try { endpoints = QueryMexEndpoint(mexAddress,binding,tokenProvider); } catch {} if(endpoints != null) { return endpoints.ToArray(); } else { return new ServiceEndpoint[]{}; } }
public static ServiceEndpoint[] GetEndpoints(string mexAddress, string issuer, string secret) { if (string.IsNullOrWhiteSpace(mexAddress)) { throw new ArgumentException("mexAddress"); } Uri address = new Uri(mexAddress); ServiceEndpointCollection endpoints = null; Binding binding; if (address.Scheme == "sb") { binding = new NetTcpRelayBinding(); } else { Debug.Assert(address.Scheme == "http" || address.Scheme == "https"); binding = new WS2007HttpRelayBinding(); } try { endpoints = QueryMexEndpoint(mexAddress, binding, issuer, secret); } catch {} if (endpoints != null) { return(endpoints.ToArray()); } else { return(new ServiceEndpoint[] {}); } }
public static ServiceEndpoint[] GetEndpoints(string mexAddress,string issuer,string secret) { if(mexAddress == null || mexAddress == "") { throw new ArgumentException("mexAddress"); } Uri address = new Uri(mexAddress); ServiceEndpointCollection endpoints = null; Binding binding; if(address.Scheme == "sb") { binding = new NetTcpRelayBinding(); } else { Debug.Assert(address.Scheme == "http" || address.Scheme == "https"); binding = new WS2007HttpRelayBinding(); } try { endpoints = QueryMexEndpoint(mexAddress,binding,issuer,secret); } catch {} if(endpoints != null) { return endpoints.ToArray(); } else { return new ServiceEndpoint[]{}; } }
static void Main(string[] args) { using (ServiceHost host = new ServiceHost(typeof(CycleService), new Uri("http://localhost:10001"))) { NetTcpRelayBinding binding = new NetTcpRelayBinding(); Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", "[TODO REPLACE WITH YOUR AZURE SERVICE BUS NAMESPACE]", "cycle"); ServiceEndpoint ep = host.AddServiceEndpoint(typeof(ICycleService), new NetTcpRelayBinding(), uri); TransportClientEndpointBehavior behavior = new TransportClientEndpointBehavior() { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "[TODO REPLACE WITH YOUR AZURE SERVICE BUS NAMESPACE SharedAccessKey]") }; ep.Behaviors.Add(behavior); host.Open(); // start the cycle ServiceBusUtils.SendCurrentDateTime(); Console.WriteLine("Host opened. Press any key to exit."); Console.Read(); } }
static void Main(string[] args) { string issuerName = ConfigurationManager.AppSettings["issuerName"]; string issuerSecret = ConfigurationManager.AppSettings["issuerSecret"]; string serviceNamespace = ConfigurationManager.AppSettings["serviceNamespace"]; string servicePath = "/"; TransportClientEndpointBehavior relayCredentials = new TransportClientEndpointBehavior(); relayCredentials.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret); NetTcpRelayBinding binding = new NetTcpRelayBinding(); // The client is not required to present a security token to the AppFabric Service Bus. binding.Security.RelayClientAuthenticationType = RelayClientAuthenticationType.None; Uri serviceAddress = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, servicePath); // Create the service host. ServiceHost host = new ServiceHost(typeof(MyService), serviceAddress); // Add the service endpoint with the NetTcpRelayBinding binding. host.AddServiceEndpoint(typeof(IMyContract), binding, serviceAddress); // Add the credentials through the endpoint behavior. host.Description.Endpoints[0].Behaviors.Add(relayCredentials); // Start the service. host.Open(); Console.WriteLine(".NET Service Bus Sample Server is running."); Console.WriteLine("Press [Enter] to exit"); Console.ReadLine(); host.Close(); }
public ServiceBusDuplexClientBase(C callback, NetTcpRelayBinding binding, EndpointAddress remoteAddress, string username, string password) : base(callback, binding, remoteAddress) { ConfigureForServiceBus(username, password); }
public HttpResponseMessage Post([FromBody] CertificateRequest request) { HttpResponseMessage result = null; if (request == null) { result = Request.CreateResponse(HttpStatusCode.InternalServerError); return(result); } var actualSecretKey = ConfigurationManager.AppSettings["ClientSecretKey"]; if (string.IsNullOrEmpty(request.ClientSecret) || !request.ClientSecret.Equals(actualSecretKey)) { result = Request.CreateResponse(HttpStatusCode.InternalServerError); return(result); } var hostName = "client-endpoint"; if (!string.IsNullOrEmpty(request.HostName)) { hostName = request.HostName; } if (request.GenerateRandom) { hostName = "client-" + Guid.NewGuid().ToString().Replace("-", ""); } byte[] data = null; var serviceNamespace = ConfigurationManager.AppSettings["ServiceNamespace"]; var serviceKey = ConfigurationManager.AppSettings["ServiceKey"]; var serviceKeyName = ConfigurationManager.AppSettings["ServiceKeyName"]; var servicePath = ConfigurationManager.AppSettings["ServicePath"]; Console.WriteLine("HOSTNAME: " + hostName); var binding = new NetTcpRelayBinding(); binding.SendTimeout = TimeSpan.FromMinutes(10); binding.ReceiveTimeout = TimeSpan.FromMinutes(10); binding.OpenTimeout = TimeSpan.FromMinutes(10); binding.CloseTimeout = TimeSpan.FromMinutes(10); var cf = new ChannelFactory <ICertificateGeneratorChannel>( binding, new EndpointAddress(ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, servicePath))); cf.Endpoint.Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(serviceKeyName, serviceKey) }); using (var ch = cf.CreateChannel()) { data = ch.GetCertificate(hostName); } result = Request.CreateResponse(HttpStatusCode.OK); result.Content = new StreamContent(new MemoryStream(data)); result.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment"); result.Content.Headers.ContentDisposition.FileName = "client.pfx"; result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); return(result); }
public ServiceBusDuplexClientBase(C callback, NetTcpRelayBinding binding, EndpointAddress remoteAddress) : base(callback, binding, remoteAddress) { ConfigureForServiceBus(); }
void ConfigureReliability(Binding binding) { if (binding is NetTcpBinding) { NetTcpBinding tcpBinding = binding as NetTcpBinding; if (tcpBinding.ReliableSession.Enabled) { m_ReliabilityEnabledLabel.Text = "Enabled"; if (tcpBinding.ReliableSession.Ordered) { m_OrderedLabel.Text = "Ordered"; } else { m_OrderedLabel.Text = "Unordered"; } } else { m_ReliabilityEnabledLabel.Text = "Disabled"; m_OrderedLabel.Text = "Unordered"; } } if (binding is NetNamedPipeBinding) { m_ReliabilityEnabledLabel.Text = "Enabled"; m_OrderedLabel.Text = "Ordered"; } if (binding is NetMsmqBinding) { m_ReliabilityEnabledLabel.Text = "Reliability: N/A"; m_OrderedLabel.Text = "Ordered: N/A"; } if (binding is BasicHttpRelayBinding) { m_ReliabilityEnabledLabel.Text = "Reliability: N/A"; m_OrderedLabel.Text = "Ordered: N/A"; } if (binding is CustomBinding) { m_ReliabilityEnabledLabel.Text = "Reliability: N/A"; m_OrderedLabel.Text = "Ordered: N/A"; } if (binding is BasicHttpBinding || binding is NetPeerTcpBinding) { m_ReliabilityEnabledLabel.Text = "Disabled"; m_OrderedLabel.Text = "Unordered"; } if (binding is WSHttpBinding) { WSHttpBinding wsBinding = binding as WSHttpBinding; if (wsBinding.ReliableSession.Enabled) { m_ReliabilityEnabledLabel.Text = "Enabled"; if (wsBinding.ReliableSession.Ordered) { m_OrderedLabel.Text = "Ordered"; } else { m_OrderedLabel.Text = "Unordered"; } } else { m_ReliabilityEnabledLabel.Text = "Disabled"; m_OrderedLabel.Text = "Unordered"; } } if (binding is WSDualHttpBinding) { m_ReliabilityEnabledLabel.Text = "Enabled"; WSDualHttpBinding wsDualBinding = binding as WSDualHttpBinding; if (wsDualBinding.ReliableSession.Ordered) { m_OrderedLabel.Text = "Ordered"; } else { m_OrderedLabel.Text = "Unordered"; } } if (binding is WSFederationHttpBinding) { WSFederationHttpBinding federatedBinding = binding as WSFederationHttpBinding; if (federatedBinding.ReliableSession.Enabled) { m_ReliabilityEnabledLabel.Text = "Enabled"; if (federatedBinding.ReliableSession.Ordered) { m_OrderedLabel.Text = "Ordered"; } else { m_OrderedLabel.Text = "Unordered"; } } else { m_ReliabilityEnabledLabel.Text = "Disabled"; m_OrderedLabel.Text = "Unordered"; } } if (binding is NetTcpRelayBinding) { NetTcpRelayBinding tcpRelayBinding = binding as NetTcpRelayBinding; if (tcpRelayBinding.ReliableSession.Enabled) { m_ReliabilityEnabledLabel.Text = "Enabled"; if (tcpRelayBinding.ReliableSession.Ordered) { m_OrderedLabel.Text = "Ordered"; } else { m_OrderedLabel.Text = "Unordered"; } } else { m_ReliabilityEnabledLabel.Text = "Disabled"; m_OrderedLabel.Text = "Unordered"; } } }
public ServiceConnectionForwarder(string serviceNamespace, string issuerName, string issuerSecret, string targetHost, string targetHostAlias, string allowedPortsString, string allowedPipesString, bool useHybrid) { this.useHybrid = useHybrid; this.targetHost = targetHost; this.noPipeConstraints = false; this.noPortConstraints = false; this.allowedPipes = new List<string>(); this.allowedPorts = new List<int>(); allowedPortsString = allowedPortsString.Trim(); if (allowedPortsString == "*") { this.noPortConstraints = true; } else { noPortConstraints = false; string[] portList = allowedPortsString.Split(','); for (int i = 0; i < portList.Length; i++) { this.allowedPorts.Add(int.Parse(portList[i].Trim())); } } allowedPipesString = allowedPipesString.Trim(); if (allowedPipesString == "*") { noPipeConstraints = true; } else { noPipeConstraints = false; string[] pipeList = allowedPipesString.Split(','); for (int i = 0; i < pipeList.Length; i++) { string pipeName = pipeList[i].Trim(); if (pipeName.StartsWith("\\", StringComparison.OrdinalIgnoreCase)) { if (!pipeName.StartsWith(localPipePrefix, StringComparison.OrdinalIgnoreCase)) { throw new ArgumentException(string.Format("Invalid pipe name in allowedPipesString. Only relative and local paths permitted: {0}", pipeName), "allowedPipesString"); } else { pipeName = pipeName.Substring(localPipePrefix.Length); } } this.allowedPipes.Add(pipeName); } } endpointVia = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "./PortBridge/" + targetHostAlias); endpointRole = "sb:"; streamBinding = new NetTcpRelayBinding(useHybrid ? EndToEndSecurityMode.None : EndToEndSecurityMode.Transport, RelayClientAuthenticationType.RelayAccessToken); streamBinding.TransferMode = TransferMode.Buffered; streamBinding.MaxReceivedMessageSize = 1024 * 1024; streamBinding.ConnectionMode = useHybrid ? TcpRelayConnectionMode.Hybrid : TcpRelayConnectionMode.Relayed; relayCreds = new TransportClientEndpointBehavior(); relayCreds.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret); }
NetTcpRelayBinding CreateClientBinding(bool useHybrid) { NetTcpRelayBinding clientBinding = new NetTcpRelayBinding(useHybrid ? EndToEndSecurityMode.None : EndToEndSecurityMode.Transport, RelayClientAuthenticationType.RelayAccessToken); clientBinding.TransferMode = TransferMode.Buffered; clientBinding.MaxReceivedMessageSize = 1024 * 1024; clientBinding.MaxBufferSize = 1024 * 1024; clientBinding.SendTimeout = TimeSpan.FromSeconds(120); clientBinding.ReceiveTimeout = TimeSpan.FromHours(1); clientBinding.ConnectionMode = useHybrid ? TcpRelayConnectionMode.Hybrid : TcpRelayConnectionMode.Relayed; return clientBinding; }
public static ServiceHost CreateServiceBusRelayHost(string serviceNamespace, string servicePath, string issuerName, string issuerSecret, Type serviceType) { var relayBinding = new NetTcpRelayBinding(EndToEndSecurityMode.None, RelayClientAuthenticationType.None); return(CreateServiceBusHost(serviceNamespace, servicePath, issuerName, issuerSecret, relayBinding, serviceType)); }
public static void EnableDiscovery(this ServiceHost host, Uri scope, bool enableMEX = true) { if (host.Description.Endpoints.Count == 0) { host.AddDefaultEndpoints(); } host.AddServiceEndpoint(new UdpDiscoveryEndpoint()); ServiceDiscoveryBehavior discovery = new ServiceDiscoveryBehavior(); discovery.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint()); host.Description.Behaviors.Add(discovery); if (enableMEX == true) { host.Description.Behaviors.Add(new ServiceMetadataBehavior()); foreach (Uri baseAddress in host.BaseAddresses) { Binding binding = null; if (baseAddress.Scheme == "net.tcp") { binding = MetadataExchangeBindings.CreateMexTcpBinding(); } if (baseAddress.Scheme == "net.pipe") { binding = MetadataExchangeBindings.CreateMexNamedPipeBinding(); } if (baseAddress.Scheme == "http") { binding = MetadataExchangeBindings.CreateMexHttpBinding(); } if (baseAddress.Scheme == "https") { binding = MetadataExchangeBindings.CreateMexHttpsBinding(); } if (baseAddress.Scheme == "sb") { binding = new NetTcpRelayBinding(); } Debug.Assert(binding != null); if (binding != null) { host.AddServiceEndpoint(typeof(IMetadataExchange), binding, "MEX"); } } } if (scope != null) { EndpointDiscoveryBehavior behavior = new EndpointDiscoveryBehavior(); behavior.Scopes.Add(scope); foreach (ServiceEndpoint endpoint in host.Description.Endpoints) { if (endpoint.IsSystemEndpoint || endpoint is DiscoveryEndpoint || endpoint is AnnouncementEndpoint || endpoint is ServiceMetadataEndpoint) { continue; } endpoint.Behaviors.Add(behavior); } } }
/// <summary> /// Extends the OnStart phase that is called by Windows Azure runtime to initialize the role instance. /// </summary> /// <returns>True if initialization succeeds, otherwise false.</returns> protected override bool OnRoleStart() { this.EnsureExists <WorkItemProcessorConfigurationExtension>(); this.EnsureExists <WorkQueueLocationResolverExtension>(); this.EnsureExists <ScalableTransformServiceClientExtension>(); this.EnsureExists <EndpointConfigurationDiscoveryExtension>(); this.EnsureExists <RulesEngineServiceClientExtension>(); this.EnsureExists <InterRoleEventSubscriberExtension>(); IWorkItemProcessorConfigurationExtension configSettingsExtension = Extensions.Find <IWorkItemProcessorConfigurationExtension>(); IEndpointConfigurationDiscoveryExtension discoveryExtension = Extensions.Find <IEndpointConfigurationDiscoveryExtension>(); IInterRoleCommunicationExtension interCommExtension = Extensions.Find <IInterRoleCommunicationExtension>(); IInterRoleEventSubscriberExtension interCommSubscriber = Extensions.Find <IInterRoleEventSubscriberExtension>(); CloudQueueLocation inputQueueLocation = new CloudQueueLocation() { StorageAccount = configSettingsExtension.Settings.CloudStorageAccount, QueueName = configSettingsExtension.Settings.WorkItemQueue, VisibilityTimeout = configSettingsExtension.Settings.WorkItemQueueVisibilityTimeout }; CloudQueueLocation outputQueueLocation = new CloudQueueLocation() { StorageAccount = configSettingsExtension.Settings.CloudStorageAccount, QueueName = configSettingsExtension.Settings.OutputQueue, VisibilityTimeout = configSettingsExtension.Settings.OutputQueueVisibilityTimeout }; // Instantiate queue listeners. var inputQueueListener = new CloudQueueListenerExtension <XDocument>(inputQueueLocation); var outputQueueListener = new CloudQueueListenerExtension <XDocument>(outputQueueLocation); // Configure the input queue listener. inputQueueListener.QueueEmpty += HandleQueueEmptyEvent; inputQueueListener.DequeueBatchSize = configSettingsExtension.Settings.DequeueBatchSize; inputQueueListener.DequeueInterval = configSettingsExtension.Settings.MinimumIdleInterval; // Configure the output queue listener. outputQueueListener.QueueEmpty += HandleQueueEmptyEvent; outputQueueListener.DequeueBatchSize = configSettingsExtension.Settings.DequeueBatchSize; outputQueueListener.DequeueInterval = configSettingsExtension.Settings.MinimumIdleInterval; // Instantiate queue subscribers. InputQueueSubscriberExtension inputQueueSubscriber = new InputQueueSubscriberExtension(); OutputQueueSubscriberExtension outputQueueSubscriber = new OutputQueueSubscriberExtension(); // Register subscribers with queue listeners. inputQueueListener.Subscribe(inputQueueSubscriber); outputQueueListener.Subscribe(outputQueueSubscriber); // Register custom extensions for this worker role. Extensions.Add(inputQueueSubscriber); Extensions.Add(outputQueueSubscriber); Extensions.Add(outputQueueListener); Extensions.Add(inputQueueListener); var contractTypeMatchCondition = ServiceEndpointDiscoveryCondition.ContractTypeExactMatch(typeof(IScalableTransformationServiceContract)); var bindingTypeMatchCondition = ServiceEndpointDiscoveryCondition.BindingTypeExactMatch(typeof(NetTcpRelayBinding)); discoveryExtension.RegisterDiscoveryAction(new[] { contractTypeMatchCondition, bindingTypeMatchCondition }, (endpoint) => { NetTcpRelayBinding relayBinding = endpoint.Binding as NetTcpRelayBinding; if (relayBinding != null) { relayBinding.TransferMode = TransferMode.Streamed; } }); // Register a subscriber for all inter-role communication events. if (interCommExtension != null && interCommSubscriber != null) { this.interCommSubscription = interCommExtension.Subscribe(interCommSubscriber); } return(true); }
/// <summary> /// Installs an event dispatcher that can be contacted from anywhere /// </summary> public static void UseAzureServiceBusRelayEventDispatcher(this EventDispatcherConfigurationBuilder builder, string serviceNamespace, string servicePath, string keyName, string sharesAccessKey, NetTcpRelayBinding netTcpRelayBinding = null) { builder.UseEventDispatcher(context => { var eventStore = context.Get <IEventStore>(); return(new AzureServiceBusRelayEventDispatcher(eventStore, serviceNamespace, servicePath, keyName, sharesAccessKey, netTcpRelayBinding)); }); }
/// <summary> /// Returns a client communication channel of type <typeparamref name="T"/> for communication with the specified Service Bus relay endpoint. /// </summary> /// <typeparam name="T">The type of the client communication channel. Must inherit from service contract as well as <see cref="System.ServiceModel.IClientChannel"/>.</typeparam> /// <param name="serviceNamespace">The service namespace name used by the application.</param> /// <param name="servicePath">The service path that follows the host name section of the URI.</param> /// <param name="issuerName">The issuer name.</param> /// <param name="issuerSecret">The issuer secret.</param> /// <returns>An instance of the communication channel of a specified type that is bound to the specified endpoint.</returns> public static T CreateServiceBusRelayClient <T>(string serviceNamespace, string servicePath, string issuerName, string issuerSecret) where T : IClientChannel { var relayBinding = new NetTcpRelayBinding(EndToEndSecurityMode.None, RelayClientAuthenticationType.None); return(CreateServiceBusClient <T>(serviceNamespace, servicePath, issuerName, issuerSecret, relayBinding)); }
private static byte[] GeneratePdf(string html) { var binding = new NetTcpRelayBinding(); binding.MaxReceivedMessageSize = 2147483647; binding.MaxBufferSize = 2147483647; var cf = new ChannelFactory<IPdfGeneratorChannel>( binding, new EndpointAddress(ServiceBusEnvironment.CreateServiceUri("sb", "dw-sea", "pdf"))); cf.Endpoint.Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "5EefGkLJ6vDO3r2/+B71NWDv4JMKT8wPtoLtPqXW1Uw=") }); using (var ch = cf.CreateChannel()) { var bytes = ch.GeneratePdfWithHtml(html); return bytes; } }
public void ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext endpointContext) { System.ServiceModel.Channels.Binding binding; if (endpointContext == null) { throw new ArgumentNullException("endpointContext"); } if (endpointContext.Endpoint.Binding == null) { throw new ArgumentNullException("endpointContext.Binding"); } if (endpointContext.Endpoint.Binding is CustomBinding) { BindingElementCollection elements = ((CustomBinding)endpointContext.Endpoint.Binding).Elements; if (elements.Find <HttpRelayTransportBindingElement>() != null) { elements.Remove <HttpsTransportBindingElement>(); if (WSHttpRelayBindingBase.TryCreate(elements, out binding)) { StandardRelayBindingImporter.SetBinding(endpointContext.Endpoint, binding); return; } if (BasicHttpRelayBinding.TryCreate(elements, out binding)) { StandardRelayBindingImporter.SetBinding(endpointContext.Endpoint, binding); return; } } else if (elements.Find <TcpRelayTransportBindingElement>() != null && NetTcpRelayBinding.TryCreate(elements, out binding)) { StandardRelayBindingImporter.SetBinding(endpointContext.Endpoint, binding); } } }