static void Main(string[] args)
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
TransportClientEndpointBehavior relayCredentials = new TransportClientEndpointBehavior();
relayCredentials.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "HelloService");
ServiceHost host = new ServiceHost(typeof(HelloService), address);
host.Description.Endpoints[0].Behaviors.Add(relayCredentials);
host.Open();
Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
host.Close();
}
private MessageBufferClient GetOrCreateQueue(TransportClientEndpointBehavior sharedSecredServiceBusCredential, Uri queueUri, ref MessageBufferPolicy queuePolicy)
{
MessageBufferClient client;
try
{
client = MessageBufferClient.GetMessageBuffer(sharedSecredServiceBusCredential, queueUri);
MessageBufferPolicy currentQueuePolicy = client.GetPolicy();
queuePolicy = currentQueuePolicy;
// Queue already exists.
return(client);
}
//catch (EndpointNotFoundException)
catch (FaultException)
{
// Exception when retrieving the current queue policy.
// Queue Not found; absorb and make a new queue below.
// Other exceptions get bubbled up.
}
catch (Exception)
{
}
try
{
client = MessageBufferClient.CreateMessageBuffer(sharedSecredServiceBusCredential, queueUri, queuePolicy);
}
catch (Exception)
{
throw;
}
//Created new Queue.
return(client);
}
static void Main(string[] args)
{
// Replace {service namespace} with your service name space.
EndpointAddress address = new EndpointAddress(ServiceBusEnvironment.CreateServiceUri("https", "{service namespace}", "ProcessDataWorkflowService"));
BasicHttpRelayBinding binding = new BasicHttpRelayBinding();
// Provide the Service Bus credential.
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.CredentialType = TransportClientCredentialType.SharedSecret;
// Replace {issuer name} and {issuer secret} with your credential.
sharedSecretServiceBusCredential.Credentials.SharedSecret.IssuerName = "{issuer name}";
sharedSecretServiceBusCredential.Credentials.SharedSecret.IssuerSecret = "{issuer secret}";
ChannelFactory <IProcessDataWorkflowServiceChannel> factory = new ChannelFactory <IProcessDataWorkflowServiceChannel>(binding, address);
factory.Endpoint.Behaviors.Add(sharedSecretServiceBusCredential);
factory.Open();
IProcessDataWorkflowServiceChannel channel = factory.CreateChannel();
channel.Open();
Console.WriteLine("Processing 10...");
Console.WriteLine("Service returned: " + channel.ProcessData(new ProcessDataRequest(0)).@string);
Console.WriteLine("Processing 30...");
Console.WriteLine("Service returned: " + channel.ProcessData(new ProcessDataRequest(30)).@string);
channel.Close();
factory.Close();
Console.Read();
}
static void Main(string[] args)
{
string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
NamespaceManager namespaceClient = NamespaceManager.CreateFromConnectionString(connectionString);
Uri address = new Uri(namespaceClient.Address, "Customer");
ServiceHost host = new ServiceHost(typeof(CustomerService), address);
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.TokenProvider = namespaceClient.Settings.TokenProvider;
var endpoint = host.AddServiceEndpoint(typeof(ICustomerContract), new NetTcpRelayBinding("default"), address);
endpoint.Behaviors.Add(sharedSecretServiceBusCredential);
host.Open();
checkDatabase();
Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
host.Close();
}
static void Main(string[] args)
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS Key Name (e.g., \"RootManageSharedAccessKey\"): ");
string keyName = Console.ReadLine();
Console.Write("Your SAS Key: ");
string key = Console.ReadLine();
// WebHttpRelayBinding uses transport security by default
Uri address = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespace, "SyndicationService");
TransportClientEndpointBehavior clientBehavior = new TransportClientEndpointBehavior();
clientBehavior.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key);
WebServiceHost host = new WebServiceHost(typeof(SyndicationService), address);
host.Description.Endpoints[0].Behaviors.Add(clientBehavior);
host.Open();
Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
host.Close();
}
static void Main(string[] args)
{
var host = new ServiceHost(typeof (Calculator));
var relayBinding = new WebHttpRelayBinding {MaxReceivedMessageSize = int.MaxValue};
relayBinding.Security.Mode = EndToEndWebHttpSecurityMode.Transport;
relayBinding.Security.RelayClientAuthenticationType = RelayClientAuthenticationType.RelayAccessToken;
var sdb = host.Description.Behaviors.Find<ServiceDebugBehavior>();
if (sdb == null)
{
sdb.IncludeExceptionDetailInFaults = true;
host.Description.Behaviors.Add(sdb);
}
var endpoint = host.AddServiceEndpoint(typeof (ICalculator), relayBinding, uri);
var sharedSecretBehavior = new TransportClientEndpointBehavior
{
TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret)
};
endpoint.Behaviors.Add(sharedSecretBehavior);
endpoint.Behaviors.Add(new WebHttpBehavior());
host.Open();
Console.WriteLine("Host opened at {0}", uri);
Console.Read();
}
public override void Run()
{
// Retrieve Settings from App.Config
string servicePath = ConfigurationManager.AppSettings["ServicePath"];
string serviceNamespace = ConfigurationManager.AppSettings["ServiceNamespace"];
string issuerName = ConfigurationManager.AppSettings["IssuerName"];
string issuerSecret = ConfigurationManager.AppSettings["IssuerSecret"];
// Construct a Service Bus URI
Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, servicePath);
// Create a Behavior for the Credentials
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
// Create the Service Host
host = new ServiceHost(typeof(EchoService), uri);
ContractDescription contractDescription = ContractDescription.GetContract(typeof(IEchoContract), typeof(EchoService));
ServiceEndpoint serviceEndPoint = new ServiceEndpoint(contractDescription);
serviceEndPoint.Address = new EndpointAddress(uri);
serviceEndPoint.Binding = new NetTcpRelayBinding();
serviceEndPoint.Behaviors.Add(sharedSecretServiceBusCredential);
host.Description.Endpoints.Add(serviceEndPoint);
// Open the Host
host.Open();
while (true)
{
//Do Nothing
}
}
public override void Refresh(ServiceBusNode node,TransportClientEndpointBehavior credential)
{
MessageBufferPolicy policy = node.Policy as MessageBufferPolicy;
int overflowIndex = 0;
switch(policy.OverflowPolicy)
{
case OverflowPolicy.RejectIncomingMessage:
{
overflowIndex = 0;
break;
}
default:
{
throw new InvalidOperationException("Unrecognized overflow value");
}
}
m_OverflowComboBox.Text = m_OverflowComboBox.Items[overflowIndex] as string;
m_ExpirationTime.Text = policy.ExpiresAfter.TotalMinutes.ToString();
m_CountTextBox.Text = policy.MaxMessageCount.ToString();
base.Refresh(node,credential);
}
//The same as two, but different style creating environments
private static void WS2007HttpRelayClientOne()
{
Console.WriteLine("Please enter any key to contact server...");
Console.ReadLine();
// Configure the credentials through an endpoint behavior.
TransportClientEndpointBehavior relayCredentials = new TransportClientEndpointBehavior();
relayCredentials.TokenProvider =
TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "fBLL/4/+rEsCOiTQPNPS6DJQybykqE2HdVBsILrzMLY=");
// Get the service address.
// Use the https scheme because by default the binding uses SSL for transport security.
Uri address = ServiceBusEnvironment.CreateServiceUri("https", "johnsonwangnz", "MyService");
// Create the binding with default settings.
WS2007HttpRelayBinding binding = new WS2007HttpRelayBinding();
// Create a channel factory for the specified channel type.
// This channel factory is used to create client channels to the service.
// Each client channel the channel factory creates is configured to use the
// WS2007HttpRelayBinding that is passed to the constructor of the channel.
var channelFactory = new ChannelFactory<IEchoContract>(
binding, new EndpointAddress(address));
channelFactory.Endpoint.Behaviors.Add(relayCredentials);
// Create and open the client channel.
IEchoContract echoService = channelFactory.CreateChannel();
var result = echoService.Echo("HelloWorld!");
Console.WriteLine(result);
Console.ReadLine();
}
public Consumer()
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
// Configure queue settings.
this.queueDescription = new QueueDescription(MyQueuePath);
// Setting Max Size and TTL for demonstration purpose
// but can be changed per user discretion to suite their system needs.
// Refer service bus documentation to understand the limitations.
// Setting Queue max size to 1GB where as default Max Size is 5GB.
this.queueDescription.MaxSizeInMegabytes = 1024;
// Setting message TTL to 5 days where as default TTL is 14 days.
this.queueDescription.DefaultMessageTimeToLive = TimeSpan.FromDays(5);
// Create management credentials.
this.credential = new TransportClientEndpointBehavior()
{
TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret)
};
// Create the URI for the queue.
this.namespaceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, String.Empty);
Console.WriteLine("Service Bus Namespace Uri address '{0}'", this.namespaceUri.AbsoluteUri);
}
public async Task Run(string namespaceAddress, string queueName, string receiveToken)
{
try
{
// Create MessageReceiver for queue which requires session
Console.WriteLine("Ready to receive messages from {0}...",queueName);
// Creating the service host object as defined in config
using (var serviceHost = new ServiceHost(typeof (SequenceProcessingService), new Uri(new Uri(namespaceAddress), queueName)))
{
var authBehavior = new TransportClientEndpointBehavior(TokenProvider.CreateSharedAccessSignatureTokenProvider(receiveToken));
serviceHost.Description.Behaviors.Add(new ErrorServiceBehavior());
foreach (var ep in serviceHost.Description.Endpoints) { ep.EndpointBehaviors.Add(authBehavior);}
// Subscribe to the faulted event.
serviceHost.Faulted += serviceHost_Faulted;
// Start service
serviceHost.Open();
Console.WriteLine("\nPress [Enter] to close ServiceHost.");
Console.ReadLine();
// Close the service
serviceHost.Close();
}
}
catch (Exception exception)
{
Console.WriteLine("Exception occurred: {0}", exception);
Console.WriteLine("\nPress [Enter] to exit.");
Console.ReadLine();
}
}
private void InitBindingInCode(string solutionName, string solutionPassword, string servicePath, ConnectivityMode onewayConnectivityMode, Type serviceType)
{
//ServiceBusEnvironment.OnewayConnectivity.Mode = onewayConnectivityMode;
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", solutionName, servicePath);
ServiceUri = address.ToString();
Host = new ServiceHost(serviceType, address);
ContractDescription contractDescription = ContractDescription.GetContract(typeof(IOnewayEnergyServiceOperations), typeof(OnewayEnergyServiceOperations));
ServiceEndpoint serviceEndPoint = new ServiceEndpoint(contractDescription);
serviceEndPoint.Address = new EndpointAddress(ServiceUri);
serviceEndPoint.Binding = new NetOnewayRelayBinding();
TransportClientEndpointBehavior behavior = ServiceBusHelper.GetUsernamePasswordBehavior(solutionName, solutionPassword);
serviceEndPoint.Behaviors.Add(behavior);
Host.Description.Endpoints.Add(serviceEndPoint);
ServiceRegistrySettings settings = new ServiceRegistrySettings();
settings.DiscoveryMode = DiscoveryType.Public;
settings.DisplayName = address.ToString();
foreach (ServiceEndpoint se in Host.Description.Endpoints)
{
se.Behaviors.Add(settings);
}
Host.Open();
}
//typeof(OnewayEnergyServiceOperations)
private void InitService(string serviceNamespace, string issuerName, string issuerKey, string servicePath, ConnectivityMode onewayConnectivityMode, Type serviceType, bool usePassword)
{
ServiceBusEnvironment.SystemConnectivity.Mode = onewayConnectivityMode;
// Host = new ServiceHost(serviceType, address);
Host = new ServiceHost(serviceType);
if (usePassword)
{
TransportClientEndpointBehavior behavior = ServiceBusHelper.GetUsernamePasswordBehavior(issuerName, issuerKey);
Host.Description.Endpoints[0].Behaviors.Add(behavior);
}
ServiceUri = Host.Description.Endpoints[0].ListenUri.ToString();
ServiceRegistrySettings settings = new ServiceRegistrySettings();
settings.DiscoveryMode = DiscoveryType.Public;
settings.DisplayName = ServiceUri;
foreach (ServiceEndpoint se in Host.Description.Endpoints)
{
se.Behaviors.Add(settings);
}
Host.Open();
}
private void InitNetEventRelayClient()
{
string issuerName = tsSolutionName.Text;
string issuerKey = tsSolutionPassword.Text;
string serviceNamespaceDomain = tsSolutionToConnect.Text;
try
{
TransportClientEndpointBehavior behavior = new TransportClientEndpointBehavior();
string token = SharedSecretTokenProvider.ComputeSimpleWebTokenString(issuerName, issuerKey);
behavior.TokenProvider = SimpleWebTokenProvider.CreateSimpleWebTokenProvider(token);
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespaceDomain, "Gateway/MulticastService/");
// netEventRelayChannelFactory = new ChannelFactory<IMulticastGatewayChannel>("RelayMulticastEndpoint", new EndpointAddress(serviceUri));
netEventRelayChannelFactory = new ChannelFactory <IMulticastGatewayChannel>("RelayMulticastEndpoint");
netEventRelayChannelFactory.Endpoint.Behaviors.Add(behavior);
netEventRelayChannel = netEventRelayChannelFactory.CreateChannel();
netEventRelayChannel.Open();
SendONLINEValue();
AddLog("Connected to " + netEventRelayChannelFactory.Endpoint.Address.Uri.ToString());
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public override void Refresh(ServiceBusNode node, TransportClientEndpointBehavior credential)
{
MessageBufferPolicy policy = node.Policy as MessageBufferPolicy;
int overflowIndex = 0;
switch (policy.OverflowPolicy)
{
case OverflowPolicy.RejectIncomingMessage:
{
overflowIndex = 0;
break;
}
default:
{
throw new InvalidOperationException("Unrecognized overflow value");
}
}
m_OverflowComboBox.Text = m_OverflowComboBox.Items[overflowIndex] as string;
m_ExpirationTime.Text = policy.ExpiresAfter.TotalMinutes.ToString();
m_CountTextBox.Text = policy.MaxMessageCount.ToString();
base.Refresh(node, credential);
}
void EnableDiscovery()
{
Debug.Assert(State != CommunicationState.Opened);
IEndpointBehavior registryBehavior = new ServiceRegistrySettings(DiscoveryType.Public);
foreach (ServiceEndpoint endpoint in Description.Endpoints)
{
endpoint.Behaviors.Add(registryBehavior);
}
//Launch the service to monitor discovery requests
DiscoveryRequestService discoveryService = new DiscoveryRequestService(Description.Endpoints.ToArray());
discoveryService.DiscoveryResponseBinding = DiscoveryResponseBinding;
m_DiscoveryHost = new ServiceHost(discoveryService);
m_DiscoveryHost.AddServiceEndpoint(typeof(IServiceBusDiscovery), DiscoveryRequestBinding, DiscoveryAddress.AbsoluteUri);
TransportClientEndpointBehavior credentials = (this as IServiceBusProperties).Credential;
m_DiscoveryHost.Description.Endpoints[0].Behaviors.Add(credentials);
m_DiscoveryHost.Description.Endpoints[0].Behaviors.Add(registryBehavior);
m_DiscoveryHost.Open();
}
static void Main(string[] args)
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
TransportClientEndpointBehavior relayCredentials = new TransportClientEndpointBehavior();
relayCredentials.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "CalculatorService");
//ServiceHost host = new ServiceHost(typeof(CalculatorService));
ServiceHost host = new ServiceHost(typeof(CalculatorService), address);
host.Description.Endpoints[0].Behaviors.Add(relayCredentials);
host.Open();
Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
host.Close();
}
static void Main(string[] args)
{
Console.WriteLine("CloudTrace Console");
Console.WriteLine("Connecting ...");
//Retrieve Settings from App.Config
string servicePath = ConfigurationManager.AppSettings["CloudTraceServicePath"];
string serviceNamespace = ConfigurationManager.AppSettings["CloudTraceServiceNamespace"];
string issuerName = ConfigurationManager.AppSettings["CloudTraceIssuerName"];
string issuerSecret = ConfigurationManager.AppSettings["CloudTraceIssuerSecret"];
//Construct a Service Bus URI
Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, servicePath);
//Create a Behavior for the Credentials
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.CredentialType = TransportClientCredentialType.SharedSecret;
sharedSecretServiceBusCredential.Credentials.SharedSecret.IssuerName = issuerName;
sharedSecretServiceBusCredential.Credentials.SharedSecret.IssuerSecret = issuerSecret;
//Create the Service Host
ServiceHost host = new ServiceHost(typeof(TraceService), uri);
ServiceEndpoint serviceEndPoint = host.AddServiceEndpoint(typeof(ITraceContract), new NetEventRelayBinding(), String.Empty);
serviceEndPoint.Behaviors.Add(sharedSecretServiceBusCredential);
//Open the Host
host.Open();
Console.WriteLine("Connected To: " + uri.ToString());
Console.WriteLine("Hit [Enter] to exit");
//Wait Until the Enter Key is Pressed and Close the Host
Console.ReadLine();
host.Close();
}
private static void Three()
{
Console.WriteLine("Starting service...");
// Configure the credentials through an endpoint behavior.
TransportClientEndpointBehavior relayCredentials = new TransportClientEndpointBehavior();
relayCredentials.TokenProvider =
TokenProvider.CreateSharedAccessSignatureTokenProvider("ListenAccessKeyMyService", "3VXc5wQwu479N/w2MaLtsk9fA7WWJsamsxtWcr8zbCY=");
// Create the binding with default settings.
WS2007HttpRelayBinding binding = new WS2007HttpRelayBinding();
// it must be false to use previously generated relay endpoint and its special credentials
binding.IsDynamic = false;
//binding.Security.Mode = EndToEndSecurityMode.Message;
// Get the service address.
// Use the https scheme because by default the binding uses SSL for transport security.
Uri address = ServiceBusEnvironment.CreateServiceUri("https", "johnsonwangnz", "MyService");
// Create the service host.
ServiceHost host = new ServiceHost(typeof(EchoService), address);
// Add the service endpoint with the WS2007HttpRelayBinding.
host.AddServiceEndpoint(typeof(IEchoContract), binding, address);
// Add the credentials through the endpoint behavior.
host.Description.Endpoints[0].Behaviors.Add(relayCredentials);
// Start the service.
host.Open();
Console.WriteLine("Listening...");
Console.ReadLine();
host.Close();
}
private MessageBufferClient GetMessageBufferClient()
{
TransportClientEndpointBehavior behavior = GetACSSecurity(txtIssuerName.Text, txtIssuerKey.Text);
Uri messageBufferUri = GetMessageBufferUri();
return(MessageBufferClient.GetMessageBuffer(behavior, messageBufferUri));
}
public AzureProxyHandler(Uri requestUrl, Uri responseUrl)
{
_credentials = new TransportClientEndpointBehavior {
CredentialType = TransportClientCredentialType.SharedSecret
};
_credentials.Credentials.SharedSecret.IssuerName = Manager.Configuration.Azure.IssuerName;
_credentials.Credentials.SharedSecret.IssuerSecret = Manager.Configuration.Azure.IssuerSecret;
Init(requestUrl, responseUrl);
ServicePointManager.DefaultConnectionLimit = 50;
_requestBinding = new BasicHttpRelayBinding(EndToEndBasicHttpSecurityMode.None, RelayClientAuthenticationType.None);
_requestBinding.MaxReceivedMessageSize = int.MaxValue;
_requestBinding.TransferMode = TransferMode.Streamed;
_requestBinding.AllowCookies = false;
_requestBinding.ReceiveTimeout = TimeSpan.MaxValue;
_requestBinding.ReaderQuotas.MaxArrayLength = int.MaxValue;
_requestBinding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
_requestBinding.MaxReceivedMessageSize = int.MaxValue;
_requestBinding.MaxBufferSize = 4 * 1024 * 1024;
_requestBinding.MaxBufferPoolSize = 32 * 4 * 1024 * 1024;
WebMessageEncodingBindingElement encoderBindingElement = new WebMessageEncodingBindingElement();
encoderBindingElement.ReaderQuotas.MaxArrayLength = int.MaxValue;
encoderBindingElement.ReaderQuotas.MaxStringContentLength = int.MaxValue;
encoderBindingElement.ReaderQuotas.MaxDepth = 128;
encoderBindingElement.ReaderQuotas.MaxBytesPerRead = 65536;
encoderBindingElement.ContentTypeMapper = new RawContentTypeMapper();
_webEncoder = encoderBindingElement.CreateMessageEncoderFactory().Encoder;
}
static void Main(string[] args)
{
string issuerName = "owner";
string issuerSecret = "y+4vWY/Ryoen5avmC4CPAYTHj/OpkUQ7eykVhxNjr2w=";
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
// Cria o URI do serviço baseado no namespace do serviço
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", "spf-nspace", "EchoService");
// Cria o serviço host
ServiceHost host = new ServiceHost(typeof(EchoService), address);
//Cria o comportamento para o endpoint
IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
//Adiciona as credenciais do Service Bus a todos os endpoints configurados na configuração
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
endpoint.Behaviors.Add(serviceRegistrySettings);
endpoint.Behaviors.Add(sharedSecretServiceBusCredential);
}
// Abre o serviço.
host.Open();
Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
// Fecha o serviço.
host.Close();
}
private static void MessageOnly()
{
var transportClientEndpointBehavior = new TransportClientEndpointBehavior
{
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(sendKeyName, sendKeyValue)
};
var serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, _queueName);
var netMessagingBinding = new NetMessagingBinding
{
PrefetchCount = 10,
TransportSettings = new NetMessagingTransportSettings
{
BatchFlushInterval = TimeSpan.FromSeconds(0)
}
};
var serviceEndpoint = new ServiceEndpoint(ContractDescription.GetContract(typeof(IRequest)),
netMessagingBinding,
new EndpointAddress(serviceUri));
serviceEndpoint.Behaviors.Add(transportClientEndpointBehavior);
var channelFactory = new ChannelFactory<IRequest>(serviceEndpoint);
var channel = channelFactory.CreateChannel();
Console.WriteLine("Press any key to send message...");
Console.ReadKey();
channel.SendMessage("Hello from wcf client");
Console.WriteLine("Message sent");
Console.ReadKey();
}
public AzureProxyHandler(Uri requestUrl, Uri responseUrl)
{
_credentials = new TransportClientEndpointBehavior {
CredentialType = TransportClientCredentialType.SharedSecret
};
_credentials.Credentials.SharedSecret.IssuerName = Manager.Configuration.Azure.IssuerName;
_credentials.Credentials.SharedSecret.IssuerSecret = Manager.Configuration.Azure.IssuerSecret;
Init(requestUrl, responseUrl);
ServicePointManager.DefaultConnectionLimit = 50;
_requestBinding = new BasicHttpRelayBinding(EndToEndBasicHttpSecurityMode.None, RelayClientAuthenticationType.None);
_requestBinding.MaxReceivedMessageSize = int.MaxValue;
_requestBinding.TransferMode = TransferMode.Streamed;
_requestBinding.AllowCookies = false;
_requestBinding.ReceiveTimeout = TimeSpan.MaxValue;
_requestBinding.ReaderQuotas.MaxArrayLength = int.MaxValue;
_requestBinding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
_requestBinding.MaxReceivedMessageSize = int.MaxValue;
_requestBinding.MaxBufferSize = 4 * 1024 * 1024;
_requestBinding.MaxBufferPoolSize = 32 * 4 * 1024 * 1024;
WebMessageEncodingBindingElement encoderBindingElement = new WebMessageEncodingBindingElement();
encoderBindingElement.ReaderQuotas.MaxArrayLength = int.MaxValue;
encoderBindingElement.ReaderQuotas.MaxStringContentLength = int.MaxValue;
encoderBindingElement.ReaderQuotas.MaxDepth = 128;
encoderBindingElement.ReaderQuotas.MaxBytesPerRead = 65536;
encoderBindingElement.ContentTypeMapper = new RawContentTypeMapper();
_webEncoder = encoderBindingElement.CreateMessageEncoderFactory().Encoder;
}
static void Main(string[] args)
{
#region With Local End Point
//ChannelFactory<INorthService> proxy = new ChannelFactory<INorthService>("tcpep");
//INorthService obj = proxy.CreateChannel();
//foreach (var item in obj.GetCategories())
//{
// Console.WriteLine(item);
//}
#endregion
#region With Service Bus EndPoint
TransportClientEndpointBehavior tcep = new TransportClientEndpointBehavior();
NamespaceManager nm = NamespaceManager.CreateFromConnectionString(ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"].ToString());
tcep.TokenProvider = nm.Settings.TokenProvider;
ChannelFactory <INorthService> proxy = new ChannelFactory <INorthService>("tcpsbep");
proxy.Endpoint.EndpointBehaviors.Add(tcep);
INorthService obj = proxy.CreateChannel();
//foreach (var item in obj.GetProductsByCategory(2))
//{
// Console.WriteLine(item);
//}
foreach (var item in obj.GetProducts())
{
Console.WriteLine(item);
}
#endregion
}
public Consumer()
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
// Create the policy for the message buffer.
this.policy = new MessageBufferPolicy();
this.policy.Authorization = AuthorizationPolicy.Required;
this.policy.MaxMessageCount = 10;
// Messages in the message buffer expire after 5 minutes.
this.policy.ExpiresAfter = TimeSpan.FromMinutes(5);
this.policy.OverflowPolicy = OverflowPolicy.RejectIncomingMessage;
this.policy.TransportProtection = TransportProtectionPolicy.AllPaths;
// Create the credentials object for the endpoint.
this.credential = new TransportClientEndpointBehavior();
this.credential.CredentialType = TransportClientCredentialType.SharedSecret;
this.credential.Credentials.SharedSecret.IssuerName = issuerName;
this.credential.Credentials.SharedSecret.IssuerSecret = issuerSecret;
// Create the URI for the message buffer.
this.uri = ServiceBusEnvironment.CreateServiceUri(Uri.UriSchemeHttps, serviceNamespace, "MessageBuffer");
Console.WriteLine("Message buffer address '{0}'", this.uri.AbsoluteUri);
}
public async Task Run(string connectionString)
{
var sbb = new ServiceBusConnectionStringBuilder(connectionString);
// Create MessageReceiver for queue which requires session
Console.WriteLine("Ready to receive messages from {0}...", SessionQueueName);
// Creating the service host object as defined in config
using (var serviceHost = new ServiceHost(typeof(SequenceProcessingService), new Uri(sbb.GetAbsoluteRuntimeEndpoints()[0], SessionQueueName)))
{
var authBehavior = new TransportClientEndpointBehavior(TokenProvider.CreateSharedAccessSignatureTokenProvider(sbb.SharedAccessKeyName, sbb.SharedAccessKey));
serviceHost.Description.Behaviors.Add(new ErrorServiceBehavior());
foreach (var ep in serviceHost.Description.Endpoints)
{
ep.EndpointBehaviors.Add(authBehavior);
}
// Subscribe to the faulted event.
serviceHost.Faulted += serviceHost_Faulted;
// Start service
serviceHost.Open();
Console.WriteLine("\nPress [Enter] to close ServiceHost.");
await Task.WhenAny(
Task.Run(() => Console.ReadKey()),
Task.Delay(TimeSpan.FromSeconds(10))
);
// Close the service
serviceHost.Close();
}
}
static void Main(string[] args)
{
// 将{service namespace}替换为你的服务命名空间.
EndpointAddress address = new EndpointAddress(ServiceBusEnvironment.CreateServiceUri("https", "{service namespace}", "ProcessDataWorkflowService"));
BasicHttpRelayBinding binding = new BasicHttpRelayBinding();
// 提供Service Bus证书.
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.CredentialType = TransportClientCredentialType.SharedSecret;
// 将{issuer name}和{issuer secret}替换为你的证书.
sharedSecretServiceBusCredential.Credentials.SharedSecret.IssuerName = "{issuer name}";
sharedSecretServiceBusCredential.Credentials.SharedSecret.IssuerSecret = "{issuer secret}";
ChannelFactory <IProcessDataWorkflowServiceChannel> factory = new ChannelFactory <IProcessDataWorkflowServiceChannel>(binding, address);
factory.Endpoint.Behaviors.Add(sharedSecretServiceBusCredential);
factory.Open();
IProcessDataWorkflowServiceChannel channel = factory.CreateChannel();
channel.Open();
Console.WriteLine("正在处理 10...");
Console.WriteLine("服务返回: " + channel.ProcessData(new ProcessDataRequest(0)).@string);
Console.WriteLine("正在处理 30...");
Console.WriteLine("服务返回: " + channel.ProcessData(new ProcessDataRequest(30)).@string);
channel.Close();
factory.Close();
Console.Read();
}
static void Main(string[] args)
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "SimpleWebTokenAuthenticationService");
TransportClientEndpointBehavior behavior = new TransportClientEndpointBehavior();
behavior.TokenProvider = TokenProvider.CreateSimpleWebTokenProvider(
ComputeSimpleWebTokenString(issuerName, issuerSecret));
ServiceHost host = new ServiceHost(typeof(EchoService), address);
host.Description.Endpoints[0].Behaviors.Add(behavior);
host.Open();
Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
host.Close();
}
static void Main(string[] args)
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "PingService");
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
ServiceHost host = new ServiceHost(typeof(PingService), address);
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
endpoint.Behaviors.Add(sharedSecretServiceBusCredential);
}
host.Open();
Console.WriteLine("Press [Enter] to exit.");
Console.ReadLine();
host.Close();
}
public async Task<RelayConnection> ConnectAsync()
{
var tb = new TransportClientEndpointBehavior(tokenProvider);
var bindingElement = new TcpRelayTransportBindingElement(
RelayClientAuthenticationType.RelayAccessToken)
{
TransferMode = TransferMode.Buffered,
ConnectionMode = TcpRelayConnectionMode.Relayed,
ManualAddressing = true
};
bindingElement.GetType()
.GetProperty("TransportProtectionEnabled",
BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(bindingElement, true);
var rt = new CustomBinding(
new BinaryMessageEncodingBindingElement(),
bindingElement);
var cf = rt.BuildChannelFactory<IDuplexSessionChannel>(tb);
await Task.Factory.FromAsync(cf.BeginOpen, cf.EndOpen, null);
var ch = cf.CreateChannel(new EndpointAddress(address));
await Task.Factory.FromAsync(ch.BeginOpen, ch.EndOpen, null);
return new RelayConnection(ch)
{
WriteTimeout = (int) rt.SendTimeout.TotalMilliseconds,
ReadTimeout = (int) rt.ReceiveTimeout.TotalMilliseconds
};
}
private static void Two()
{
Console.WriteLine("Starting service...");
// Configure the credentials through an endpoint behavior.
TransportClientEndpointBehavior relayCredentials = new TransportClientEndpointBehavior();
relayCredentials.TokenProvider =
TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "fBLL/4/+rEsCOiTQPNPS6DJQybykqE2HdVBsILrzMLY=");
// Create the binding with default settings.
WebHttpRelayBinding binding = new WebHttpRelayBinding();
binding.Security.RelayClientAuthenticationType = RelayClientAuthenticationType.None;
// Get the service address.
// Use the https scheme because by default the binding uses SSL for transport security.
Uri address = ServiceBusEnvironment.CreateServiceUri("https", "johnsonwangnz", "Rest");
// Create the web service host.
WebServiceHost host = new WebServiceHost(typeof(EchoRestService), address);
// Add the service endpoint with the WS2007HttpRelayBinding.
host.AddServiceEndpoint(typeof(IEchoRestContract), binding, address);
// Add the credentials through the endpoint behavior.
host.Description.Endpoints[0].Behaviors.Add(relayCredentials);
// Start the service.
host.Open();
Console.WriteLine("Listening...");
Console.ReadLine();
host.Close();
}
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));
}
static void Main(string[] args)
{
Console.WriteLine("CloudTrace Console");
Console.WriteLine("Connecting ...");
//Retrieve Settings from App.Config
string servicePath = ConfigurationManager.AppSettings["CloudTraceServicePath"];
string serviceNamespace = ConfigurationManager.AppSettings["CloudTraceServiceNamespace"];
string issuerName = ConfigurationManager.AppSettings["CloudTraceIssuerName"];
string issuerSecret = ConfigurationManager.AppSettings["CloudTraceIssuerSecret"];
//Construct a Service Bus URI
Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, servicePath);
//Create a Behavior for the Credentials
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
//Create the Service Host
ServiceHost host = new ServiceHost(typeof(TraceService), uri);
ServiceEndpoint serviceEndPoint = host.AddServiceEndpoint(typeof(ITraceContract), new NetEventRelayBinding(), String.Empty);
serviceEndPoint.Behaviors.Add(sharedSecretServiceBusCredential);
//Open the Host
host.Open();
Console.WriteLine("Connected To: " + uri.ToString());
Console.WriteLine("Hit [Enter] to exit");
//Wait Until the Enter Key is Pressed and Close the Host
Console.ReadLine();
host.Close();
}
/// <summary>
/// Initializes a new instance of the reliable Windows Azure Service Bus Message Buffer client connected to the specified message buffer
/// located on the specified Service Bus endpoint and utilizing the specified custom retry policy.
/// </summary>
/// <param name="queueName">The name of the target message buffer (queue).</param>
/// <param name="sbEndpointInfo">The endpoint details.</param>
/// <param name="retryPolicy">The custom retry policy that will ensure reliable access to the underlying HTTP/REST-based infrastructure.</param>
public ReliableServiceBusQueue(string queueName, ServiceBusEndpointInfo sbEndpointInfo, RetryPolicy retryPolicy)
{
Guard.ArgumentNotNullOrEmptyString(queueName, "queueName");
Guard.ArgumentNotNull(sbEndpointInfo, "sbEndpointInfo");
Guard.ArgumentNotNull(retryPolicy, "retryPolicy");
this.sbEndpointInfo = sbEndpointInfo;
this.retryPolicy = retryPolicy;
this.queuePolicy = new MessageBufferPolicy
{
ExpiresAfter = TimeSpan.FromMinutes(120),
MaxMessageCount = 100000,
OverflowPolicy = OverflowPolicy.RejectIncomingMessage
};
var address = ServiceBusEnvironment.CreateServiceUri(WellKnownProtocolScheme.SecureHttp, sbEndpointInfo.ServiceNamespace, String.Concat(sbEndpointInfo.ServicePath, !sbEndpointInfo.ServicePath.EndsWith("/") ? "/" : "", queueName));
var credentialsBehaviour = new TransportClientEndpointBehavior();
credentialsBehaviour.CredentialType = TransportClientCredentialType.SharedSecret;
credentialsBehaviour.Credentials.SharedSecret.IssuerName = sbEndpointInfo.IssuerName;
credentialsBehaviour.Credentials.SharedSecret.IssuerSecret = sbEndpointInfo.IssuerSecret;
MessageBufferClient msgBufferClient = null;
this.retryPolicy.ExecuteAction(() =>
{
msgBufferClient = MessageBufferClient.CreateMessageBuffer(credentialsBehaviour, address, this.queuePolicy, DefaultQueueMessageVersion);
});
this.queueClient = msgBufferClient;
}
private static ChannelFactory <T> CreateServiceBusClientChannelFactory <T>(string serviceNamespace, string servicePath, string issuerName, string issuerSecret, Binding binding)
{
Guard.ArgumentNotNullOrEmptyString(serviceNamespace, "serviceNamespace");
Guard.ArgumentNotNullOrEmptyString(servicePath, "servicePath");
Guard.ArgumentNotNullOrEmptyString(issuerName, "issuerName");
Guard.ArgumentNotNullOrEmptyString(issuerSecret, "issuerSecret");
Guard.ArgumentNotNull(binding, "binding");
var callToken = TraceManager.DebugComponent.TraceIn(serviceNamespace, servicePath, binding.Name);
var address = ServiceBusEnvironment.CreateServiceUri(WellKnownProtocolScheme.ServiceBus, serviceNamespace, servicePath);
var credentialsBehaviour = new TransportClientEndpointBehavior();
credentialsBehaviour.CredentialType = TransportClientCredentialType.SharedSecret;
credentialsBehaviour.Credentials.SharedSecret.IssuerName = issuerName;
credentialsBehaviour.Credentials.SharedSecret.IssuerSecret = issuerSecret;
var endpoint = new ServiceEndpoint(ContractDescription.GetContract(typeof(T)), binding, new EndpointAddress(address));
endpoint.Behaviors.Add(credentialsBehaviour);
// Apply default endpoint configuration.
ServiceEndpointConfiguration.ConfigureDefaults(endpoint);
ChannelFactory <T> clientChannelFactory = new ChannelFactory <T>(endpoint);
TraceManager.DebugComponent.TraceOut(callToken, endpoint.Address.Uri);
return(clientChannelFactory);
}
public async Task <RelayConnection> ConnectAsync()
{
var tb = new TransportClientEndpointBehavior(tokenProvider);
var bindingElement = new TcpRelayTransportBindingElement(
RelayClientAuthenticationType.RelayAccessToken)
{
TransferMode = TransferMode.Buffered,
ConnectionMode = TcpRelayConnectionMode.Relayed,
ManualAddressing = true
};
bindingElement.GetType()
.GetProperty("TransportProtectionEnabled",
BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(bindingElement, true);
var rt = new CustomBinding(
new BinaryMessageEncodingBindingElement(),
bindingElement);
var cf = rt.BuildChannelFactory <IDuplexSessionChannel>(tb);
await Task.Factory.FromAsync(cf.BeginOpen, cf.EndOpen, null);
var ch = cf.CreateChannel(new EndpointAddress(address));
await Task.Factory.FromAsync(ch.BeginOpen, ch.EndOpen, null);
return(new RelayConnection(ch)
{
WriteTimeout = (int)rt.SendTimeout.TotalMilliseconds,
ReadTimeout = (int)rt.ReceiveTimeout.TotalMilliseconds
});
}
void DeleteBuffers(ServiceBusTreeNode treeNode)
{
if (treeNode.ServiceBusNode != null)
{
if (treeNode.ServiceBusNode.Policy != null)
{
if (treeNode.ServiceBusNode.Policy is MessageBufferPolicy)
{
string nodeAddress = treeNode.ServiceBusNode.Address;
nodeAddress = nodeAddress.Replace(@"sb://", @"https://");
TransportClientEndpointBehavior credential = Graphs[ServiceNamespace.ToLower()].Credential;
Uri address = new Uri(nodeAddress);
try
{
MessageBufferClient.GetMessageBuffer(credential, address).DeleteMessageBuffer();
}
catch
{}
}
}
}
foreach (TreeNode node in treeNode.Nodes)
{
DeleteBuffers(node as ServiceBusTreeNode);
}
}
static void Main(string[] args)
{
#region With Local End Point
//ServiceHost host = new ServiceHost(typeof(NorthSVC));
//host.Open();
//Console.WriteLine("Service is running, press any key to exist!!");
//Console.ReadKey(true);
//host.Close();
#endregion
#region With ServiceBus EndPoint
TransportClientEndpointBehavior tcep = new TransportClientEndpointBehavior();
NamespaceManager nm = NamespaceManager.CreateFromConnectionString(ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"].ToString());
tcep.TokenProvider = nm.Settings.TokenProvider;
ServiceHost host = new ServiceHost(typeof(NorthSVC));
foreach (ServiceEndpoint item in host.Description.Endpoints)
{
item.EndpointBehaviors.Add(tcep);
}
host.Open();
Console.WriteLine("Service Bus Service is running, press any key to stop!!");
Console.ReadKey(true);
host.Close();
#endregion
}
/// <summary>
/// Start the two way listener running as a service host, listening for requests on the Azure Service Bus.
/// </summary>
public void Start()
{
try
{
var SBaccessKey = _listenerConfig.ServiceBusSASKey;
var serviceHost = new ServiceHost(_messageProcessor);
MessageProcessingService.Host = serviceHost;
Log($"Starting TwoWay Listener on {_listenerConfig.ServiceBusEndpoint} with access policy {_listenerConfig.SharedAccessKeyName}");
var tokenProvider =
TokenProvider.CreateSharedAccessSignatureTokenProvider(_listenerConfig.SharedAccessKeyName,
SBaccessKey);
// accessKeyTask.Result);
var transportClient = new TransportClientEndpointBehavior(tokenProvider);
serviceHost.AddServiceEndpoint(typeof(ITwoWayServiceEndpointPlugin),
new WS2007HttpRelayBinding(),
_listenerConfig.ServiceBusEndpoint).Behaviors.Add(transportClient);
serviceHost.Open();
Log($"listening ... on {serviceHost.Description.Endpoints[0].Address}");
}
catch (Exception ex)
{
Log(ex.ToString());
throw;
}
}
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();
}
}
public Consumer()
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
// Configure queue settings.
this.queueDescription = new QueueDescription(MyQueuePath);
// Setting Max Size and TTL for demonstration purpose
// but can be changed per user discretion to suite their system needs.
// Refer service bus documentation to understand the limitations.
// Setting Queue max size to 1GB where as default Max Size is 5GB.
this.queueDescription.MaxSizeInMegabytes = 1024;
// Setting message TTL to 5 days where as default TTL is 14 days.
this.queueDescription.DefaultMessageTimeToLive = TimeSpan.FromDays(5);
// Create management credentials.
this.credential = new TransportClientEndpointBehavior()
{
TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret)
};
// Create the URI for the queue.
this.namespaceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, String.Empty);
Console.WriteLine("Service Bus Namespace Uri address '{0}'", this.namespaceUri.AbsoluteUri);
}
static void SetServiceBusCredentials(IEnumerable <ServiceEndpoint> endpoints, string issuer, string secret)
{
TransportClientEndpointBehavior behavior = new TransportClientEndpointBehavior();
TokenProvider tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuer, secret);
SetServiceBusCredentials(endpoints, tokenProvider);
}
public static void VerifyBuffer(string bufferAddress,string issuer,string secret)
{
TransportClientEndpointBehavior creds = new TransportClientEndpointBehavior();
creds.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuer,secret);
VerifyBuffer(bufferAddress,creds);
}
public ReverseWebProxy(Uri upstreamUri, Uri downstreamUri, TransportClientEndpointBehavior credentials)
{
this.upstreamUri = upstreamUri;
this.downstreamUri = downstreamUri;
this.upstreamBasePath = this.upstreamUri.PathAndQuery;
if (this.upstreamBasePath.EndsWith("/"))
{
this.upstreamBasePath = this.upstreamBasePath.Substring(0, this.upstreamBasePath.Length - 1);
}
ServicePointManager.DefaultConnectionLimit = 50;
WebHttpRelayBinding relayBinding = new WebHttpRelayBinding(EndToEndWebHttpSecurityMode.None, RelayClientAuthenticationType.None);
relayBinding.MaxReceivedMessageSize = int.MaxValue;
relayBinding.TransferMode = TransferMode.Streamed;
relayBinding.AllowCookies = false;
relayBinding.ReceiveTimeout = TimeSpan.MaxValue;
relayBinding.ReaderQuotas.MaxArrayLength = int.MaxValue;
relayBinding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
this.upstreamBinding = relayBinding;
WebMessageEncodingBindingElement encoderBindingElement = new WebMessageEncodingBindingElement();
encoderBindingElement.ReaderQuotas.MaxArrayLength = int.MaxValue;
encoderBindingElement.ReaderQuotas.MaxStringContentLength = int.MaxValue;
encoderBindingElement.ContentTypeMapper = new RawContentTypeMapper();
encoder = encoderBindingElement.CreateMessageEncoderFactory().Encoder;
this.credentials = credentials;
}
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();
}
}
private bool startRelay1()
{
try
{
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", ConfigurationManager.AppSettings["serviceNamespace"], "BridgeService");
TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", ConfigurationManager.AppSettings["sasKey"]);
channelFactory = new ChannelFactory <IBridgeChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
channelFactory.Endpoint.Behaviors.Add(sasCredential);
channel = channelFactory.CreateChannel();
channel.Open();
g("BridgeService Channel opened");
return(true);
}
catch (System.ServiceModel.EndpointNotFoundException)
{
ex("The BridgeService endpoint was not found");
return(false);
}
catch (Exception ex1)
{
ex(System.Reflection.MethodBase.GetCurrentMethod().Name + " " + ex1.ToString());
return(false);
}
}
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);
}
private static TransportClientEndpointBehavior GetCredentials()
{
TransportClientEndpointBehavior credentialBehavior = new TransportClientEndpointBehavior();
credentialBehavior.CredentialType = TransportClientCredentialType.SharedSecret;
credentialBehavior.Credentials.SharedSecret.IssuerName = issuerName;
credentialBehavior.Credentials.SharedSecret.IssuerSecret = issuerKey;
return credentialBehavior;
}
public static void VerifyBuffer(string bufferAddress,string issuer,string secret)
{
TransportClientEndpointBehavior credential = new TransportClientEndpointBehavior();
credential.CredentialType = TransportClientCredentialType.SharedSecret;
credential.Credentials.SharedSecret.IssuerName = issuer;
credential.Credentials.SharedSecret.IssuerSecret = secret;
VerifyBuffer(bufferAddress,credential);
}
public static void PurgeBuffer(Uri bufferAddress,TransportClientEndpointBehavior credential)
{
Debug.Assert(BufferExists(bufferAddress,credential));
MessageBufferClient client = MessageBufferClient.GetMessageBuffer(credential,bufferAddress);
MessageBufferPolicy policy = client.GetPolicy();
client.DeleteMessageBuffer();
MessageBufferClient.CreateMessageBuffer(credential,bufferAddress,policy);
}
static void Main(string[] args)
{
// HACK: 3 constantes adicionais, para se poderem alterar 'a vontade
const string serviceSheme = "sb";
// HACK: linha seguinte descomentada, para nao se estar sempre a escrever
const string serviceNamespace = "cmfservicebusnamespace"; // "catiavaz";
const string servicePath = "EchoService";
// HACK: declaracao de 2 constantes, para nao se estar sempre a escrever
string issuerName = "owner"; // "owner";
string issuerSecret = "CZzrHKiB2QjRCJjBC5kFwXVrWV4w5qpBphpwpt43Tmw="; // "MYKEY";
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
Console.Write("Your Service Namespace: ");
//string serviceNamespace = Console.ReadLine(); // HACK: linha comentada, para nao se estar sempre a escrever
Console.Write("Your Issuer Name: ");
//string issuerName = Console.ReadLine(); // HACK: linha comentada, para nao se estar sempre a escrever
Console.Write("Your Issuer Secret: ");
//string issuerSecret = Console.ReadLine(); // HACK: linha comentada, para nao se estar sempre a escrever
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri(serviceSheme, serviceNamespace, servicePath);
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new
TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.TokenProvider =
TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
ChannelFactory<IEchoChannel> channelFactory =
new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
channelFactory.Endpoint.Behaviors.Add(sharedSecretServiceBusCredential);
IEchoChannel channel = channelFactory.CreateChannel();
channel.Open();
Console.WriteLine("Enter text to echo (or [Enter] to exit):");
string input = Console.ReadLine();
while (input != String.Empty)
{
try
{
Console.WriteLine("Server echoed: {0}", channel.Echo(input));
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.Message);
}
input = Console.ReadLine();
}
channel.Close();
channelFactory.Close();
}
public ServiceBusTreeNode(ExplorerForm form,ServiceBusNode serviceBusNode,string text,int imageIndex) : base(text,imageIndex,imageIndex)
{
Form = form;
ServiceBusNode = serviceBusNode;
if(serviceBusNode != null)
{
string serviceNamespace = ExtractNamespace(new Uri(serviceBusNode.Address));
Credential = form.Graphs[serviceNamespace.ToLower()].Credential;
}
}
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);
}
private static void GetChannelFactory()
{
string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
NamespaceManager namespaceClient = NamespaceManager.CreateFromConnectionString(connectionString);
Uri serviceUri = new Uri(namespaceClient.Address, "Customer");
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
sharedSecretServiceBusCredential.TokenProvider = namespaceClient.Settings.TokenProvider;
channelFactory = new ChannelFactory<ICustomerChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
channelFactory.Endpoint.Behaviors.Add(sharedSecretServiceBusCredential);
}
public virtual void Refresh(ServiceBusNode node,TransportClientEndpointBehavior credential)
{
Node = node;
Credential = credential;
Address = GetRealAddress(node.Address).AbsoluteUri;
m_ItemNameLabel.Text = node.Name;
m_AddressLabel.Text = GetRealAddress(node.Address).AbsoluteUri;
TrimLable(m_ItemNameLabel,34);
TrimLable(m_AddressLabel,69);
}
public override void Refresh(ServiceBusNode node,TransportClientEndpointBehavior credential)
{
base.Refresh(node,credential);
m_Address = Address;
//The feed does not show correct transport - always http/https, so remove all transports
m_Address = m_Address.Replace(@"sb://",@"[transport]://");
m_AddressLabel.Text = m_Address;
TrimLable(m_AddressLabel,69);
}
static void SetBehavior(IEnumerable<ServiceEndpoint> endpoints,TransportClientEndpointBehavior credential)
{
foreach(ServiceEndpoint endpoint in endpoints)
{
if(endpoint.Binding is NetTcpRelayBinding ||
endpoint.Binding is WSHttpRelayBinding ||
endpoint.Binding is NetOnewayRelayBinding)
{
endpoint.Behaviors.Add(credential);
}
}
}
static void Main(string[] args)
{
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Http;
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
// The issuer secret is the Service Bus namespace management key.
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
// Create the service URI based on the service namespace.
Uri address = ServiceBusEnvironment.CreateServiceUri(Uri.UriSchemeHttps, serviceNamespace, "RemoteService");
Console.WriteLine("Service address: " + address);
// Create the credentials object for the endpoint.
TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior()
{
TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret)
};
// Create the binding object.
WS2007HttpRelayBinding binding = new WS2007HttpRelayBinding();
binding.Security.Mode = EndToEndSecurityMode.Transport;
// Create the service host reading the configuration.
ServiceHost host = new ServiceHost(typeof(RemoteService));
host.AddServiceEndpoint(typeof(IServiceEndpointPlugin), binding, address);
// Create the ServiceRegistrySettings behavior for the endpoint.
IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
// Add the Service Bus credentials to all endpoints specified in configuration.
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
endpoint.Behaviors.Add(serviceRegistrySettings);
endpoint.Behaviors.Add(sharedSecretServiceBusCredential);
}
// Open the service.
host.Open();
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
// Close the service.
Console.Write("Closing the service host...");
host.Close();
Console.WriteLine(" done.");
}
static void Listen()
{
string serviceNamespace;
string serviceIdentityName;
string serviceIdentityKey;
Console.WriteLine("Service Namespace:");
serviceNamespace = Console.ReadLine();
Console.WriteLine("Service Identity:");
serviceIdentityName = Console.ReadLine();
Console.WriteLine("Service Identity Key:");
serviceIdentityKey = Console.ReadLine();
TransportClientEndpointBehavior behavior = new TransportClientEndpointBehavior();
behavior.TokenProvider = SharedSecretTokenProvider.CreateSharedSecretTokenProvider(serviceIdentityName, serviceIdentityKey);
var address = ServiceBusEnvironment.CreateServiceUri(Uri.UriSchemeHttps, serviceNamespace, "Demo/OneWayListener");
// binding
var binding = new WS2007HttpRelayBinding();
binding.Security.Mode = EndToEndSecurityMode.Transport;
var host = new ServiceHost(typeof (CRMOnlineOneWayListenerService));
var endPoint = host.AddServiceEndpoint(typeof (IServiceEndpointPlugin), binding, address);
var serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Private);
endPoint.Behaviors.Add(serviceRegistrySettings);
endPoint.Behaviors.Add(behavior);
try
{
// Open the service.
host.Open();
Console.WriteLine("Host Open. Listening on endpoint Address: " + address);
}
catch (TimeoutException timeout)
{
Console.WriteLine("Opening the service timed out, details below:");
Console.WriteLine(timeout.Message);
}
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
// Close the service.
Console.Write("Closing the service host...");
host.Close();
Console.WriteLine(" done.");
}
