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