public Task Run(string serviceBusHostName, string token)
{
Console.Write("Enter your nick:");
var chatNickname = Console.ReadLine();
Console.Write("Enter room name:");
var session = Console.ReadLine();
var serviceAddress = new UriBuilder("sb", serviceBusHostName, -1, "/chat/" + session).ToString();
var netEventRelayBinding = new NetEventRelayBinding();
var tokenBehavior = new TransportClientEndpointBehavior(TokenProvider.CreateSharedAccessSignatureTokenProvider(token));
using (var host = new ServiceHost(this))
{
host.AddServiceEndpoint(typeof(IChat), netEventRelayBinding, serviceAddress)
.EndpointBehaviors.Add(tokenBehavior);
host.Open();
using (var channelFactory = new ChannelFactory <IChat>(netEventRelayBinding, serviceAddress))
{
channelFactory.Endpoint.Behaviors.Add(tokenBehavior);
var channel = channelFactory.CreateChannel();
this.RunChat(channel, chatNickname);
channelFactory.Close();
}
host.Close();
}
return(Task.FromResult(true));
}
public Task Run(string serviceBusHostName, string token)
{
Console.Write("Enter your nick:");
var chatNickname = Console.ReadLine();
Console.Write("Enter room name:");
var session = Console.ReadLine();
var serviceAddress = new UriBuilder("sb", serviceBusHostName, -1, "/chat/" + session).ToString();
var netEventRelayBinding = new NetEventRelayBinding();
var tokenBehavior = new TransportClientEndpointBehavior(TokenProvider.CreateSharedAccessSignatureTokenProvider(token));
using (var host = new ServiceHost(this))
{
host.AddServiceEndpoint(typeof(IChat), netEventRelayBinding, serviceAddress)
.EndpointBehaviors.Add(tokenBehavior);
host.Open();
using (var channelFactory = new ChannelFactory<IChat>(netEventRelayBinding, serviceAddress))
{
channelFactory.Endpoint.Behaviors.Add(tokenBehavior);
var channel = channelFactory.CreateChannel();
this.RunChat(channel, chatNickname);
channelFactory.Close();
}
host.Close();
}
return Task.FromResult(true);
}
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));
}
protected override void InitializeFrom(Binding binding)
{
base.InitializeFrom(binding);
NetEventRelayBinding netEventRelayBinding = (NetEventRelayBinding)binding;
this.MaxBufferPoolSize = netEventRelayBinding.MaxBufferPoolSize;
this.MaxBufferSize = netEventRelayBinding.MaxBufferSize;
this.MaxConnections = netEventRelayBinding.MaxConnections;
this.MaxReceivedMessageSize = netEventRelayBinding.MaxReceivedMessageSize;
this.ListenBacklog = netEventRelayBinding.ListenBacklog;
this.Security.InitializeFrom(netEventRelayBinding.Security);
this.ReaderQuotas.InitializeFrom(netEventRelayBinding.ReaderQuotas);
}
protected override void OnApplyConfiguration(Binding binding)
{
NetEventRelayBinding listenBacklog = (NetEventRelayBinding)binding;
listenBacklog.ListenBacklog = this.ListenBacklog;
listenBacklog.MaxBufferPoolSize = this.MaxBufferPoolSize;
if (base.ElementInformation.Properties["maxBufferSize"].ValueOrigin != PropertyValueOrigin.Default)
{
listenBacklog.MaxBufferSize = this.MaxBufferSize;
}
listenBacklog.MaxConnections = this.MaxConnections;
listenBacklog.MaxReceivedMessageSize = this.MaxReceivedMessageSize;
this.Security.ApplyConfiguration(listenBacklog.Security);
this.ReaderQuotas.ApplyConfiguration(listenBacklog.ReaderQuotas);
}
public ServiceEndpoint CreateEndpoint()
{
var contractDescription = ContractDescription.GetContract(typeof(T));
var endPointAddress = new EndpointAddress(GetServiceButUri());
var binding = new NetEventRelayBinding(EndToEndSecurityMode.None, RelayEventSubscriberAuthenticationType.None);
var endpoint = new ServiceEndpoint(contractDescription, binding, endPointAddress);
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(serviceBusSettings.SharedAccessKeyName, serviceBusSettings.SharedAccessKey);
var behavior = new TransportClientEndpointBehavior(tokenProvider);
endpoint.EndpointBehaviors.Add(behavior);
return(endpoint);
}
static void Main(string[] args)
{
try
{
string serviceNamespaceDomain = ServiceBusHelper.GetServiceBusSolutionName();
string issuerName = "owner";
string issuerSecret = "wJBJaobUmarWn6kqv7QpaaRh3ttNVr3w1OjiotVEOL4=";
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
TransportClientEndpointBehavior relayCredentials = new TransportClientEndpointBehavior();
relayCredentials.TokenProvider = SharedSecretTokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
Uri serviceAddress = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespaceDomain,
"Gateway/MulticastService/");
ServiceHost host = new ServiceHost(typeof(MulticastGatewayOperations), serviceAddress);
host.Description.Endpoints[0].Behaviors.Add(relayCredentials);
host.Open();
Console.WriteLine("ServiceUri:" + serviceAddress.ToString());
Console.WriteLine("Service registered for public discovery.");
NetEventRelayBinding binding = host.Description.Endpoints[0].Binding as NetEventRelayBinding;
if (binding != null)
{
Console.WriteLine("Scheme:" + binding.Scheme);
Console.WriteLine("Security Mode:" + binding.Security.Mode);
Console.WriteLine("Security RelayAuthType:" + binding.Security.RelayClientAuthenticationType.ToString());
Console.WriteLine("Security Transport.ProtectionLevel:" + binding.Security.Transport.ProtectionLevel.ToString());
}
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
host.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void SetBinding(string bindingConfigName)
{
RelayBinding = new NetEventRelayBinding(bindingConfigName);
}
/// <summary>
/// Returns a client communication channel of type <typeparamref name="T"/> for communication with the specified Service Bus one-way event 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 CreateServiceBusEventRelayClient <T>(string serviceNamespace, string servicePath, string issuerName, string issuerSecret) where T : IClientChannel
{
var eventRelayBinding = new NetEventRelayBinding(EndToEndSecurityMode.None, RelayEventSubscriberAuthenticationType.None);
return(CreateServiceBusClient <T>(serviceNamespace, servicePath, issuerName, issuerSecret, eventRelayBinding));
}
public static ServiceHost CreateServiceBusEventRelayHost(string serviceNamespace, string servicePath, string issuerName, string issuerSecret, Type serviceType)
{
var eventRelayBinding = new NetEventRelayBinding(EndToEndSecurityMode.None, RelayEventSubscriberAuthenticationType.None);
return(CreateServiceBusHost(serviceNamespace, servicePath, issuerName, issuerSecret, eventRelayBinding, serviceType));
}
