public void GenerateFormToken_AnonymousUser()
{
// Arrange
var cookieToken = new AntiForgeryToken() { IsSessionToken = true };
var httpContext = new Mock<HttpContext>().Object;
var mockIdentity = new Mock<ClaimsIdentity>();
mockIdentity.Setup(o => o.IsAuthenticated)
.Returns(false);
var config = new AntiForgeryOptions();
var tokenProvider = new TokenProvider(
config: config,
claimUidExtractor: null,
additionalDataProvider: null);
// Act
var fieldToken = tokenProvider.GenerateFormToken(httpContext, mockIdentity.Object, cookieToken);
// Assert
Assert.NotNull(fieldToken);
Assert.Equal(cookieToken.SecurityToken, fieldToken.SecurityToken);
Assert.False(fieldToken.IsSessionToken);
Assert.Empty(fieldToken.Username);
Assert.Null(fieldToken.ClaimUid);
Assert.Empty(fieldToken.AdditionalData);
}
public ReliableClientBase(string sbNamespace, TokenProvider tokenProvider, string path, RetryPolicy<ServiceBusTransientErrorDetectionStrategy> policy)
{
mRetryPolicy = policy;
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", sbNamespace, string.Empty);
mNamespaceManager = new NamespaceManager(address, tokenProvider);
mMessagingFactory = MessagingFactory.Create(address, tokenProvider);
}
public void GenerateFormToken_AuthenticatedWithoutUsernameAndNoAdditionalData_NoAdditionalData()
{
// Arrange
var cookieToken = new AntiForgeryToken()
{
IsSessionToken = true
};
var httpContext = new Mock<HttpContext>().Object;
ClaimsIdentity identity = new MyAuthenticatedIdentityWithoutUsername();
var config = new AntiForgeryOptions();
IClaimUidExtractor claimUidExtractor = new Mock<IClaimUidExtractor>().Object;
var tokenProvider = new TokenProvider(
config: config,
claimUidExtractor: claimUidExtractor,
additionalDataProvider: null);
// Act & assert
var ex =
Assert.Throws<InvalidOperationException>(
() => tokenProvider.GenerateFormToken(httpContext, identity, cookieToken));
Assert.Equal(
"The provided identity of type " +
"'Microsoft.AspNet.Mvc.Core.Test.TokenProviderTest+MyAuthenticatedIdentityWithoutUsername' " +
"is marked IsAuthenticated = true but does not have a value for Name. " +
"By default, the anti-forgery system requires that all authenticated identities have a unique Name. " +
"If it is not possible to provide a unique Name for this identity, " +
"consider extending IAdditionalDataProvider by overriding the DefaultAdditionalDataProvider " +
"or a custom type that can provide some form of unique identifier for the current user.",
ex.Message);
}
private static MessagingFactory CreateMessagingFactory(TokenProvider tokenProvider)
{
Uri sbUri = GetLocalTcpEndpoint();
MessagingFactory messageFactory = MessagingFactory.Create(sbUri, tokenProvider);
return messageFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="TopicSender"/> class,
/// automatically creating the given topic if it does not exist.
/// </summary>
protected TopicSender(MessagingSettings settings, string topic, RetryStrategy retryStrategy)
{
this.settings = settings;
this.topic = topic;
this.tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
this.serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
try
{
new NamespaceManager(this.serviceUri, this.tokenProvider)
.CreateTopic(
new TopicDescription(topic)
{
RequiresDuplicateDetection = true,
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(30)
});
}
catch (MessagingEntityAlreadyExistsException)
{ }
// TODO: This could be injected.
this.retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(retryStrategy);
this.retryPolicy.Retrying +=
(s, e) =>
{
Trace.TraceError("An error occurred in attempt number {1} to send a message: {0}", e.LastException.Message, e.CurrentRetryCount);
};
var factory = MessagingFactory.Create(this.serviceUri, this.tokenProvider);
this.topicClient = factory.CreateTopicClient(this.topic);
}
public BrokeredServiceBehavior(ServiceEndpoint endpoint, TokenProvider tokenProvider, ReceiveMode receiveMode, Dictionary<string, string> actionMap)
{
this.endpoint = endpoint;
this.tokenProvider = tokenProvider;
this.receiveMode = receiveMode;
this.actionMap = actionMap;
}
/// <summary>
/// Initializes a new instance of the <see cref="TopicSender"/> class,
/// automatically creating the given topic if it does not exist.
/// </summary>
protected TopicSender(ServiceBusSettings settings, string topic, RetryStrategy retryStrategy)
{
this.settings = settings;
this.topic = topic;
this.tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
this.serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
// TODO: This could be injected.
this.retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(retryStrategy);
this.retryPolicy.Retrying +=
(s, e) =>
{
var handler = this.Retrying;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
Trace.TraceWarning("An error occurred in attempt number {1} to send a message: {0}", e.LastException.Message, e.CurrentRetryCount);
};
var factory = MessagingFactory.Create(this.serviceUri, this.tokenProvider);
this.topicClient = factory.CreateTopicClient(this.topic);
}
public SaslSwtHandler(TokenProvider tokenProvider, string action, string appliesTo)
: this()
{
this.action = action;
this.tokenProvider = tokenProvider;
this.appliesTo = appliesTo;
}
public ReliableTopicClient(string sbNamespace, TokenProvider tokenProvider, string path, RetryPolicy<ServiceBusTransientErrorDetectionStrategy> policy)
: base(sbNamespace, tokenProvider, path, policy)
{
//create the queue if it doesn't exist
bool needsCreation = false;
try
{
needsCreation = !mRetryPolicy.ExecuteAction<bool>(() => mNamespaceManager.TopicExists(path));
}
catch (MessagingEntityNotFoundException)
{
needsCreation = true;
}
if (needsCreation)
{
try
{
mRetryPolicy.ExecuteAction<TopicDescription>(() => mNamespaceManager.CreateTopic(path));
}
catch (MessagingEntityAlreadyExistsException)
{
//ignore this exception because queue already exists
}
}
mRetryPolicy.ExecuteAction(() => mTopicClient = mMessagingFactory.CreateTopicClient(path));
}
static async Task<string> FormatReplyTo(Uri replyTo, TokenProvider replyTokenProvider)
{
return new UriBuilder(replyTo)
{
Query = string.Format(
"tk={0}",
Uri.EscapeDataString(await replyTokenProvider.GetWebTokenAsync(replyTo.AbsoluteUri, string.Empty, false, TimeSpan.FromMinutes(1))))
}.ToString();
}
static void CreateQueue(Uri baseAddress,string queueName,QueueDescription queueDescription,TokenProvider credentials)
{
if(QueueExists(baseAddress,queueName,credentials))
{
DeleteQueue(baseAddress,queueName,credentials);
}
NamespaceManager namespaceClient = new NamespaceManager(baseAddress,credentials);
namespaceClient.CreateQueue(queueDescription);
}
static void CreateTokenProviderAndServiceUri(out TokenProvider credentials, out Uri serviceUri)
{
//TODO
// HACK: constante adicional
const string serviceSheme = "sb";
credentials = TokenProvider.CreateSharedSecretTokenProvider(IssuerName, IssuerKey);
serviceUri = ServiceBusEnvironment.CreateServiceUri(serviceSheme, ServiceNamespace, string.Empty);
}
public DelegatingTokenProvider(TokenProvider tokenProvider)
: base(tokenProvider.CacheTokens, tokenProvider.IsWebTokenSupported, tokenProvider.CacheSize, tokenProvider.TokenScope)
{
if (tokenProvider == null)
{
throw new ArgumentNullException();
}
this.tokenProvider = tokenProvider;
}
private void AddBrokeredServiceBehavior(Type serviceType, Uri address, TokenProvider tokenProvider, ReceiveMode receiveMode, bool requiresSession)
{
this.receiveMode = receiveMode;
this.requiresSession = requiresSession;
ContractDescription contractDescription = CreateContractDescription(serviceType);
ServiceEndpoint endpoint = new ServiceEndpoint(contractDescription, new BrokeredBinding(), address != null ? new EndpointAddress(address) : null);
this.Description.Behaviors.Insert(0, new BrokeredServiceBehavior(endpoint, tokenProvider, receiveMode, this.actionMap));
}
/// <summary>
/// Initializes a new instance of the <see cref="OAuthService"/> class.
/// </summary>
public OAuthService()
{
var clientProvider = new ClientProvider();
var tokenProvider = new TokenProvider();
var passwordProvider = new PasswordProvider();
var scopes = new List<string>();
this.oAuthProvider = OAuthFactory.BuildOAuthProvider(clientProvider, tokenProvider, scopes, passwordProvider: passwordProvider);
}
public BrokeredServiceHost(
Type serviceType,
Uri address,
TokenProvider tokenProvider,
ReceiveMode receiveMode,
bool requiresSession)
: base(serviceType)
{
AddBrokeredServiceBehavior(serviceType, address, tokenProvider, receiveMode, requiresSession);
}
public static NamespaceManager CreateNamespaceManager(
[NotNull] MessagingFactory factory,
TokenProvider tokenProvider = null)
{
if (factory == null) throw new ArgumentNullException("factory");
return new NamespaceManager(factory.Address, new NamespaceManagerSettings
{
TokenProvider = tokenProvider ?? CreateTokenProvider()
});
}
public BrokeredServiceHost(
object singletonInstance,
Uri address,
TokenProvider tokenProvider,
ReceiveMode receiveMode,
bool requiresSession)
: base(singletonInstance)
{
AddBrokeredServiceBehavior(singletonInstance.GetType(), address, tokenProvider, receiveMode, requiresSession);
}
public static void PurgeQueue(Uri baseAddress,string queueName,TokenProvider credentials)
{
Debug.Assert(QueueExists(baseAddress,queueName,credentials));
NamespaceManager namespaceClient = new NamespaceManager(baseAddress,credentials);
QueueDescription description = namespaceClient.GetQueue(queueName);
DeleteQueue(baseAddress,queueName,credentials);
CreateQueue(baseAddress,queueName,description,credentials);
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress,Binding binding,TokenProvider tokenProvider)
{
dynamic extendedBinding = binding;
extendedBinding.MaxReceivedMessageSize *= MessageSizeMultiplier;
MetadataExchangeClient mexClient = new MetadataExchangeClient(extendedBinding);
mexClient.SetServiceBusCredentials(tokenProvider);
MetadataSet metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return importer.ImportAllEndpoints();
}
public ServiceBusFactory(string connectionString)
{
DbConnectionStringBuilder builder = new DbConnectionStringBuilder
{
ConnectionString = connectionString
};
string endpointString;
if (!builder.TryGetStringValue("Endpoint", out endpointString))
{
throw new ArgumentException("Endpoint is not specified.", "connectionString");
}
if (!Uri.TryCreate(endpointString, UriKind.Absolute, out this.endpoint))
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, "Endpoint is not valid. {0}", endpointString),
"connectionString");
}
string managementPortString;
if (builder.TryGetStringValue("ManagementPort", out managementPortString))
{
if (!int.TryParse(managementPortString, out this.managementPort))
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, "Malformed ManagementPort. {0}", managementPortString),
"connectionString");
}
}
else
{
this.managementPort = -1;
}
string runtimePortString;
if (builder.TryGetStringValue("RuntimePort", out runtimePortString))
{
if (!int.TryParse(runtimePortString, out this.runtimePort))
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, "Malformed RuntimePort. {0}", runtimePortString),
"connectionString");
}
}
else
{
this.runtimePort = -1;
}
TokenProviderFactory factory = CreateTokenProviderFactory(builder);
this.tokenProvider = factory.Create();
}
/// <summary>
/// Create a messaging factory based on a address and token provider
/// </summary>
/// <param name="address">Base address</param>
/// <param name="tokenProvider">Token provider</param>
/// <returns>Messaging factory</returns>
public static MessagingFactory Create(Uri address, TokenProvider tokenProvider)
{
MessagingFactorySettings factorySettings = new MessagingFactorySettings();
factorySettings.TokenProvider = tokenProvider;
factorySettings.TransportType = TransportType.Amqp;
factorySettings.AmqpTransportSettings = new AmqpTransportSettings();
factorySettings.AmqpTransportSettings.Port = AmqpTransportSettings.AMQPS_PORT;
factorySettings.AmqpTransportSettings.TokenProvider = factorySettings.TokenProvider;
return Create(address, factorySettings);
}
public void GenerateCookieToken()
{
// Arrange
var tokenProvider = new TokenProvider(
config: null,
claimUidExtractor: null,
additionalDataProvider: null);
// Act
var retVal = tokenProvider.GenerateCookieToken();
// Assert
Assert.NotNull(retVal);
}
static void CreateQueue(Uri baseAddress,string queueName,TokenProvider credentials,bool requiresSession = false)
{
string address = baseAddress.AbsoluteUri;
if(address.EndsWith("/") == false)
{
address += "/";
}
address += queueName;
QueueDescription queueDescription = CreateQueueDescription(queueName,requiresSession);
Tuple<Uri,string> tuple = ParseUri(new Uri(address));
CreateQueue(baseAddress,queueName,queueDescription,credentials);
}
AzureServiceBusEndpointAddressImpl([NotNull] Data data,
AddressType addressType)
{
if (data == null)
throw new ArgumentNullException("data");
_data = data;
_tp = TokenProvider.CreateSharedSecretTokenProvider(_data.UsernameIssuer,
_data.PasswordSharedSecret);
var sbUri = ServiceBusEnvironment.CreateServiceUri("sb", _data.Namespace, string.Empty);
var mfs = new MessagingFactorySettings
{
TokenProvider = _tp,
NetMessagingTransportSettings =
{
// todo: configuration setting
BatchFlushInterval = 50.Milliseconds()
},
OperationTimeout = 3.Seconds()
};
_mff = () => MessagingFactory.Create(sbUri, mfs);
_nm = new NamespaceManager(sbUri, _tp);
string suffix = "";
if (addressType == AddressType.Queue)
_queueDescription = new QueueDescriptionImpl(data.QueueOrTopicName);
else
{
_topicDescription = new TopicDescriptionImpl(data.QueueOrTopicName);
suffix = "?topic=true";
}
_rebuiltUri = new Uri(string.Format("azure-sb://{0}:{1}@{2}/{3}{4}",
data.UsernameIssuer,
data.PasswordSharedSecret,
data.Namespace,
data.QueueOrTopicName,
suffix));
_friendlyUri = new Uri(string.Format("azure-sb://{0}/{1}{2}",
data.Namespace,
data.QueueOrTopicName,
suffix));
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionReceiver"/> class,
/// automatically creating the topic and subscription if they don't exist.
/// </summary>
protected SubscriptionReceiver(ServiceBusSettings settings, string topic, string subscription, bool processInParallel, RetryStrategy backgroundRetryStrategy)
{
this.settings = settings;
this.topic = topic;
this.subscription = subscription;
this.processInParallel = processInParallel;
this.tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
this.serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
var messagingFactory = MessagingFactory.Create(this.serviceUri, tokenProvider);
this.client = messagingFactory.CreateSubscriptionClient(topic, subscription);
if (this.processInParallel)
{
this.client.PrefetchCount = 18;
}
else
{
this.client.PrefetchCount = 14;
}
this.dynamicThrottling =
new DynamicThrottling(
maxDegreeOfParallelism: 100,
minDegreeOfParallelism: 50,
penaltyAmount: 3,
workFailedPenaltyAmount: 5,
workCompletedParallelismGain: 1,
intervalForRestoringDegreeOfParallelism: 8000);
this.receiveRetryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(backgroundRetryStrategy);
this.receiveRetryPolicy.Retrying += (s, e) =>
{
this.dynamicThrottling.Penalize();
Trace.TraceWarning(
"An error occurred in attempt number {1} to receive a message from subscription {2}: {0}",
e.LastException.Message,
e.CurrentRetryCount,
this.subscription);
};
var namespaceManager = new NamespaceManager(this.serviceUri, this.tokenProvider);
if (!namespaceManager.SubscriptionExists(topic, subscription))
{
namespaceManager.CreateSubscription(topic, subscription);
}
}
/// <summary>
/// Base class used to send and receive messages.
/// </summary>
/// <param name="configuration"></param>
public AzureSenderReceiverBase(BusConfiguration configuration) {
Guard.ArgumentNotNull(configuration, "configuration");
this.configuration = configuration;
tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(configuration.ServiceBusIssuerName, configuration.ServiceBusIssuerKey);
var servicePath = string.Empty;
if (!string.IsNullOrWhiteSpace(configuration.ServicePath)) {
servicePath = configuration.ServicePath;
}
serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", configuration.ServiceBusNamespace, servicePath);
factory = MessagingFactory.Create(serviceUri, tokenProvider);
namespaceManager = new NamespaceManager(serviceUri, tokenProvider);
EnsureTopic(configuration.TopicName);
}
/// <summary>
/// Authenticates the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="response">The response.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="secure">if set to <c>true</c> [secure].</param>
/// <param name="requiresTransportLayerSecurity">if set to <c>true</c> [requires transport layer security].</param>
/// <param name="scope">The scope.</param>
/// <returns></returns>
public IIdentity Authenticate(IncomingWebRequestContext request, OutgoingWebResponseContext response, object[] parameters, bool secure, bool requiresTransportLayerSecurity, string scope, bool allowAnonymous)
{
var clientProvider = new ClientProvider();
var passwordProvider = new PasswordProvider();
var tokenProvider = new TokenProvider();
var scopes = new List<string>();
var oAuthProvider = OAuthFactory.BuildOAuthProvider(clientProvider, tokenProvider, scopes, passwordProvider: passwordProvider);
var token = request.Headers["Authorization"];
if (string.IsNullOrWhiteSpace(token))
{
token = HttpContext.Current.Request.QueryString["access_token"];
}
else
{
if (!string.IsNullOrWhiteSpace(token) && token.StartsWith("OAuth") && token.Contains(" "))
{
var splitToken = token.Split(' ');
if (splitToken.Length > 1)
{
token = splitToken[1];
}
}
}
var authentication = oAuthProvider.VerifyToken(token, scope);
if (authentication.ErrorCode != ErrorCode.None)
{
if (allowAnonymous)
{
return null;
}
var errorCode = authentication.StatusCode();
var oauthError = authentication.Error();
if (errorCode == HttpStatusCode.Unauthorized)
{
response.Headers.Add(HttpResponseHeader.WwwAuthenticate, string.Format("OAuth realm='PollMe Service', error='{0}'", oauthError));
}
throw new WebFaultException<string>(oauthError, authentication.StatusCode());
}
return new GenericIdentity("Authorized User", "OAuth2");
}
/// <summary>
/// A connection is stored per connection string
/// </summary>
/// <param name="address"></param>
/// <param name="tokenProvider"></param>
/// <exception cref="ArgumentNullException"></exception>
public AzureServiceBusConnectionImpl(IAzureServiceBusEndpointAddress address, TokenProvider tokenProvider)
{
if (address == null)
throw new ArgumentNullException("address");
_address = address;
_tokenProvider = tokenProvider;
_serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", _address.Namespace, string.Empty);
/*When using the default lock expiration of 60 seconds, a good value for SubscriptionClient.PrefetchCount
* is 20 times the maximum processing rates of all receivers of the factory. For example,
* a factory creates 3 receivers. Each receiver can process up to 10 messages per second.
* The prefetch count should not exceed 20*3*10 = 600.By default, QueueClient.PrefetchCount
* is set to 0, which means that no additional messages are fetched from the service. */
_log.DebugFormat("Connection '{0}' created at {1}", _address, _serviceUri);
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionReceiver"/> class,
/// automatically creating the topic and subscription if they don't exist.
/// </summary>
protected SubscriptionReceiver(ServiceBusSettings settings, string topic, string subscription, RetryStrategy backgroundRetryStrategy)
{
this.settings = settings;
this.topic = topic;
this.subscription = subscription;
this.tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
this.serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
var messagingFactory = MessagingFactory.Create(this.serviceUri, tokenProvider);
this.client = messagingFactory.CreateSubscriptionClient(topic, subscription);
this.receiveRetryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(backgroundRetryStrategy);
this.receiveRetryPolicy.Retrying +=
(s, e) =>
{
Trace.TraceError("An error occurred in attempt number {1} to receive a message: {0}", e.LastException.Message, e.CurrentRetryCount);
};
}
/// <summary>
/// create security token
/// </summary>
private void initSecurityTokenprovider()
{
localUserTokenProvider = WindowsTokenProvider.CreateOAuthTokenProvider(
connBuilder.StsEndpoints,
new System.Net.NetworkCredential(Username, Password));
}
public FunctionsRepository(IHttpClientFactory httpClientFactory, TokenProvider tokenProvider)
{
this._httpClient = httpClientFactory.CreateClient("ApiClient");
_tokenProvider = tokenProvider;
this._httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", tokenProvider.AccessToken);
}
public ConvertToStlOperationApiClient(string host, TokenProvider tokenProvider)
: base(host, tokenProvider)
{
}
public static void Main(string[] args)
{
ServiceInitializer.Initialize();
string connectionString = Environment.GetEnvironmentVariable("SbusConnString");
string topic = Environment.GetEnvironmentVariable("Topic");
string payload = string.Empty;
var builder = new ServiceBusConnectionStringBuilder(connectionString);
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(
builder.SasKeyName,
builder.SasKey);
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Publish Notification");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("1. AFR - 2017");
Console.WriteLine("2. AFR - 2018");
Console.WriteLine("3. AFR - 2019");
Console.WriteLine("4. TST - 2017");
Console.WriteLine("5. TST - 2018");
Console.WriteLine("6. TST - 2019");
Console.WriteLine("-------------------------------------------------------");
while (!(Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Escape))
{
string option = Console.ReadLine();
switch (option)
{
case "1":
payload = GetSecondaryReportNotificationPayload("AFR", 2017);
break;
case "2":
payload = GetSecondaryReportNotificationPayload("AFR", 2018);
break;
case "3":
payload = GetSecondaryReportNotificationPayload("AFR", 2019);
break;
case "4":
payload = GetSecondaryReportNotificationPayload("TST", 2017);
break;
case "5":
payload = GetSecondaryReportNotificationPayload("TST", 2018);
break;
case "6":
payload = GetSecondaryReportNotificationPayload("TST", 2019);
break;
default:
break;
}
var message = new Message(Encoding.UTF8.GetBytes(payload));
Console.WriteLine($"Message Published: {payload}");
var sender = new MessageSender(
builder.Endpoint,
topic,
tokenProvider,
TransportType.AmqpWebSockets);
sender.SendAsync(message).GetAwaiter().GetResult();
}
}
public ProjectService(HttpClient httpClient, TokenProvider tokenProvider, NavigationManager navigationManager)
: base(httpClient, tokenProvider, navigationManager)
{
OnProjectAdded += (newProject) => projects.Add(newProject);
}
public GetEntityCollectionAsyncResult(string path, TokenProvider tokenProvider)
: base(tokenProvider)
{
this.path = path;
this.uri = ServiceBusEnvironment.CreateServiceUri(this.TokenProvider.ServiceNamespace, path);
}
// [DebuggerStepThrough]
static void Run()
{
var properties = new Dictionary <string, string>
{
{ servicebusNamespace, null },
{ servicebusEntityPath, null },
{ servicebusFqdnSuffix, null },
{ servicebusSendKey, null },
{ servicebusListenKey, null },
{ servicebusManageKey, null }
};
// read the settings file created by the ./setup.ps1 file
var settingsFile = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
samplePropertiesFileName);
if (File.Exists(settingsFile))
{
using (var fs = new StreamReader(settingsFile))
{
while (!fs.EndOfStream)
{
var readLine = fs.ReadLine();
if (readLine != null)
{
var propl = readLine.Trim();
var cmt = propl.IndexOf('#');
if (cmt > -1)
{
propl = propl.Substring(0, cmt).Trim();
}
if (propl.Length > 0)
{
var propi = propl.IndexOf('=');
if (propi == -1)
{
continue;
}
var propKey = propl.Substring(0, propi).Trim();
var propVal = propl.Substring(propi + 1).Trim();
if (properties.ContainsKey(propKey))
{
properties[propKey] = propVal;
}
}
}
}
}
}
// get overrides from the environment
foreach (var prop in properties)
{
var env = Environment.GetEnvironmentVariable(prop.Key);
if (env != null)
{
properties[prop.Key] = env;
}
}
var hostName = properties[servicebusNamespace] + "." + properties[servicebusFqdnSuffix];
var rootUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, "/").ToString();
var sbUri = new UriBuilder("sb", hostName, -1, "/").ToString();
var program = Activator.CreateInstance(typeof(Program));
if (program is IDynamicSample)
{
var token =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
RootSampleManageKeyName,
properties[servicebusManageKey])
.GetWebTokenAsync(rootUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDynamicSample)program).Run(sbUri, token).GetAwaiter().GetResult();
}
else if (program is IDynamicSampleWithKeys)
{
((IDynamicSampleWithKeys)program).Run(
sbUri,
RootSampleManageKeyName,
properties[servicebusManageKey],
RootSampleSendKeyName,
properties[servicebusSendKey],
RootSampleSendKeyName,
properties[servicebusListenKey]).GetAwaiter().GetResult();
}
else if (program is IBasicQueueSendReceiveSample)
{
var entityName = BasicQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IBasicQueueSendReceiveSample)program).Run(sbUri, entityName, sendToken, receiveToken).GetAwaiter().GetResult();
}
else if (program is IBasicQueueSendSample)
{
var entityName = BasicQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IBasicQueueSendSample)program).Run(sbUri, entityName, sendToken).GetAwaiter().GetResult();
}
else if (program is IBasicQueueReceiveSample)
{
var entityName = BasicQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IBasicQueueReceiveSample)program).Run(sbUri, entityName, receiveToken).GetAwaiter().GetResult();
}
else if (program is IPartitionedQueueSendReceiveSample)
{
var entityName = PartitionedQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IPartitionedQueueSendReceiveSample)program).Run(sbUri, entityName, sendToken, receiveToken).GetAwaiter().GetResult();
}
else if (program is IPartitionedQueueSendSample)
{
var entityName = PartitionedQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IPartitionedQueueSendSample)program).Run(sbUri, entityName, sendToken).GetAwaiter().GetResult();
}
else if (program is IPartitionedQueueReceiveSample)
{
var entityName = PartitionedQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IPartitionedQueueReceiveSample)program).Run(sbUri, entityName, receiveToken).GetAwaiter().GetResult();
}
else
if (program is ISessionQueueSendReceiveSample)
{
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, SessionQueueName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((ISessionQueueSendReceiveSample)program).Run(sbUri, SessionQueueName, sendToken, receiveToken).GetAwaiter().GetResult();
}
else if (program is ISessionQueueSendSample)
{
var entityName = SessionQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((ISessionQueueSendSample)program).Run(sbUri, entityName, sendToken).GetAwaiter().GetResult();
}
else if (program is ISessionQueueReceiveSample)
{
var entityName = SessionQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((ISessionQueueReceiveSample)program).Run(sbUri, entityName, receiveToken).GetAwaiter().GetResult();
}
else if (program is IDupdetectQueueSendReceiveSample)
{
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, DupdetectQueueName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDupdetectQueueSendReceiveSample)program).Run(sbUri, DupdetectQueueName, sendToken, receiveToken).GetAwaiter().GetResult();
}
else if (program is IDupdetectQueueSendSample)
{
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, DupdetectQueueName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDupdetectQueueSendSample)program).Run(sbUri, DupdetectQueueName, sendToken).GetAwaiter().GetResult();
}
else if (program is IDupdetectQueueReceiveSample)
{
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, DupdetectQueueName).ToString();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDupdetectQueueReceiveSample)program).Run(sbUri, DupdetectQueueName, receiveToken).GetAwaiter().GetResult();
}
else if (program is IBasicTopicSendReceiveSample)
{
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, BasicTopicName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IBasicTopicSendReceiveSample)program).Run(sbUri, BasicTopicName, sendToken, receiveToken).GetAwaiter().GetResult();
}
else if (program is IBasicTopicSendSample)
{
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, BasicTopicName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IBasicTopicSendSample)program).Run(sbUri, BasicTopicName, sendToken).GetAwaiter().GetResult();
}
else if (program is IBasicTopicReceiveSample)
{
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, BasicTopicName).ToString();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IBasicTopicReceiveSample)program).Run(sbUri, BasicTopicName, receiveToken).GetAwaiter().GetResult();
}
else if (program is IBasicTopicConnectionStringSample)
{
var connectionString =
ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
new Uri(rootUri),
RootSampleManageKeyName,
properties[servicebusManageKey]);
((IBasicTopicConnectionStringSample)program).Run(BasicTopicName, connectionString).GetAwaiter().GetResult();
}
else if (program is IConnectionStringSample)
{
var connectionString =
ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
new Uri(rootUri),
RootSampleManageKeyName,
properties[servicebusManageKey]);
((IConnectionStringSample)program).Run(connectionString).GetAwaiter().GetResult();
}
else if (program is IBasicQueueConnectionStringSample)
{
var connectionString =
ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
new Uri(rootUri),
RootSampleManageKeyName,
properties[servicebusManageKey]);
((IBasicQueueConnectionStringSample)program).Run(BasicQueueName, connectionString).GetAwaiter().GetResult();
}
else if (program is IDualQueueSendReceiveSample)
{
var entityName = BasicQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
var entity2Name = BasicQueue2Name;
var entity2Uri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entity2Name).ToString();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entity2Uri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDualQueueSendReceiveSample)program).Run(sbUri, entityName, sendToken, entity2Name, receiveToken).GetAwaiter().GetResult();
}
else if (program is IDualQueueSampleWithFullRights)
{
var entityName = BasicQueueName;
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entityName).ToString();
var token1 =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ManageKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
var entity2Name = BasicQueue2Name;
var entity2Uri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entity2Name).ToString();
var token2 =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ManageKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entity2Uri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDualQueueSampleWithFullRights)program).Run(sbUri, entityName, token1, entity2Name, token2).GetAwaiter().GetResult();
}
else if (program is IDualQueueSendReceiveFlipsideSample)
{
var entityUri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, BasicQueue2Name).ToString();
var sendToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
SendKeyName,
properties[servicebusSendKey])
.GetWebTokenAsync(entityUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
var entity2Name = BasicQueueName;
var entity2Uri = new UriBuilder(Uri.UriSchemeHttp, hostName, -1, entity2Name).ToString();
var receiveToken =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
ReceiveKeyName,
properties[servicebusListenKey])
.GetWebTokenAsync(entity2Uri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDualQueueSendReceiveFlipsideSample)program).Run(sbUri, BasicQueue2Name, sendToken, entity2Name, receiveToken).
GetAwaiter().
GetResult();
}
else if (program is IBasicQueueSampleWithKeys)
{
((IBasicQueueSampleWithKeys)program).Run(
sbUri,
BasicQueueName,
SendKeyName,
properties[servicebusSendKey],
ReceiveKeyName,
properties[servicebusListenKey]).GetAwaiter().GetResult();
;
}
else if (program is IDualBasicQueueSampleWithKeys)
{
((IDualBasicQueueSampleWithKeys)program).Run(
sbUri,
BasicQueueName,
BasicQueue2Name,
SendKeyName,
properties[servicebusSendKey],
ReceiveKeyName,
properties[servicebusListenKey]).GetAwaiter().GetResult();
}
}
static void CreateQueue(Uri baseAddress, string queueName, QueueDescription queueDescription, TokenProvider credentials)
{
if (QueueExists(baseAddress, queueName, credentials))
{
DeleteQueue(baseAddress, queueName, credentials);
}
NamespaceManager namespaceClient = new NamespaceManager(baseAddress, credentials);
namespaceClient.CreateQueue(queueDescription);
}
public static void DeleteQueue(Uri baseAddress, string queueName, string issuer, string secret)
{
TokenProvider credentials = TokenProvider.CreateSharedSecretTokenProvider(issuer, secret);
DeleteQueue(baseAddress, queueName, credentials);
}
public void SetTokenProvider(TokenProvider tokenProvider)
{
this.tokenProvider = tokenProvider;
}
public AuthService(TokenProvider tokenService)
{
this._tokenService = tokenService;
}
public ShrinkwrapRepairOperationApiClient(string host, TokenProvider tokenProvider)
: base(host, tokenProvider)
{
}
public void CleanUp()
{
Directory.Delete(TokenStoragePath, true);
TokenProvider.Dispose();
}
public AuthController(BookContext context, IConfiguration configuration)
{
_context = context;
this.configuration = configuration;
tokenProvider = new TokenProvider(configuration);
}
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.CredentialType = TransportClientCredentialType.SharedSecret;
//relayCreds.Credentials.SharedSecret.IssuerName = issuerName;
//relayCreds.Credentials.SharedSecret.IssuerSecret = issuerSecret;
this.relayCreds.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
}
public static void VerifyQueue(Uri baseAddress, string queueName, string issuer, string secret, bool requiresSession = false)
{
TokenProvider credentials = TokenProvider.CreateSharedSecretTokenProvider(issuer, secret);
VerifyQueue(baseAddress, queueName, credentials, requiresSession);
}
private static TopicClient CreateTopic(TokenProvider credentials, string name)
{
return(new TopicClient(name, credentials));
}
private void Run()
{
hubmessagingtopic = "skillcow"; // RoleEnvironment.GetConfigurationSettingValue("servicebustopic" + messageTopicNumber);
// TokenProvider and URI of our service namespace
tP = TokenProvider.CreateSharedSecretTokenProvider(issuer, key);
uri = ServiceBusEnvironment.CreateServiceUri("sb", "chaindateservicebus", string.Empty);
// Create NamespaceManager for the "HowToSample" service namespace
NamespaceManager namespaceManager = new NamespaceManager(uri, tP);
while (true)
{
try
{
//Wait for topic to become available
if (namespaceManager.TopicExists(hubmessagingtopic))
{
// Create a new "AllMessages" subscription on our "TestTopic"
if (!namespaceManager.SubscriptionExists(hubmessagingtopic, "allmessages"))
{
namespaceManager.CreateSubscription(hubmessagingtopic, "allmessages");
}
break;
}
Thread.Sleep(1000);
}
catch
{
}
}
// URI address and token for our "HowToSample" namespace
tP = TokenProvider.CreateSharedSecretTokenProvider(issuer, key);
uri = ServiceBusEnvironment.CreateServiceUri("sb", "chaindateservicebus", string.Empty);
// Retrieve MessageReceiver for the "AllMessages" subscription
factory = MessagingFactory.Create(uri, tP);
MessageReceiver messageReceiver =
factory.CreateMessageReceiver(hubmessagingtopic + "/subscriptions/AllMessages");
//For resending messages
//topic = factory.CreateMessageSender(hubmessagingtopic);
messageBroker = new MessageBroker(messageTopicNumber);
Random random = RandomHelper.Instance;
// Continuously process messages received from the "HighMessages" subscription
while (true)
{
BrokeredMessage message = null;
while (true) //Keep reconnecting
{
try
{
message = messageReceiver.Receive();
break;
}
catch
{
tP = TokenProvider.CreateSharedSecretTokenProvider(issuer, key);
uri = ServiceBusEnvironment.CreateServiceUri("sb", "chaindateservicebus", string.Empty);
factory = MessagingFactory.Create(uri, tP);
messageReceiver = factory.CreateMessageReceiver(hubmessagingtopic + "/subscriptions/AllMessages");
}
}
if (message != null)
{
try
{
string msgtype = message.GetBody <string>();
Interlocked.Increment(ref MessagesProcessed);
switch (msgtype)
{
case "deferred":
DeferredProcessExitCode deferredProcessExitCode = DeferredProcess.CreateAndExecute(messageBroker, message, instanceNumber, threadNumber);
break;
default:
break;
}
try
{
message.Complete();
}
catch
{
}
}
catch (Exception ex)
{
// Indicate a problem, unlock message in subscription
message.Abandon();
}
finally
{
}
}
}
}
public EmployeeService(HttpClient httpClient, TokenProvider tokenProvider)
{
this.httpClient = httpClient;
this.tokenProvider = tokenProvider;
}
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 cf = new ChannelFactory <ICertificateGeneratorChannel>(
new NetTcpRelayBinding(),
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);
}
async Task ReceiveMessagesAsync(string namespaceAddress, string queueName, string receiveToken, CancellationToken cancellationToken)
{
var doneReceiving = new TaskCompletionSource <bool>();
var receiverFactory = MessagingFactory.Create(
namespaceAddress,
new MessagingFactorySettings
{
TransportType = TransportType.Amqp,
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(receiveToken)
});
receiverFactory.RetryPolicy = new RetryExponential(TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5), 10);
var receiver = await receiverFactory.CreateMessageReceiverAsync(queueName, ReceiveMode.PeekLock);
// close the receiver and factory when the CancellationToken fires
cancellationToken.Register(
async() =>
{
await receiver.CloseAsync();
await receiverFactory.CloseAsync();
doneReceiving.SetResult(true);
});
// register the OnMessageAsync callback
receiver.OnMessageAsync(
async message =>
{
if (message.Label != null &&
message.ContentType != null &&
message.Label.Equals("Scientist", StringComparison.InvariantCultureIgnoreCase) &&
message.ContentType.Equals("application/json", StringComparison.InvariantCultureIgnoreCase))
{
var body = message.GetBody <Stream>();
dynamic scientist = JsonConvert.DeserializeObject(new StreamReader(body, true).ReadToEnd());
lock (Console.Out)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(
"\t\t\t\tMessage received: \n\t\t\t\t\t\tMessageId = {0}, \n\t\t\t\t\t\tSequenceNumber = {1}, \n\t\t\t\t\t\tEnqueuedTimeUtc = {2}," +
"\n\t\t\t\t\t\tExpiresAtUtc = {5}, \n\t\t\t\t\t\tContentType = \"{3}\", \n\t\t\t\t\t\tSize = {4}, \n\t\t\t\t\t\tContent: [ firstName = {6}, name = {7} ]",
message.MessageId,
message.SequenceNumber,
message.EnqueuedTimeUtc,
message.ContentType,
message.Size,
message.ExpiresAtUtc,
scientist.firstName,
scientist.name);
Console.ResetColor();
}
await message.CompleteAsync();
}
else
{
await message.DeadLetterAsync("ProcessingError", "Don't know what to do with this message");
}
},
new OnMessageOptions {
AutoComplete = false, MaxConcurrentCalls = 1
});
await doneReceiving.Task;
}
public AmqpQueueClient(ServiceBusConnection servicebusConnection, string entityPath, ReceiveMode mode)
: base(servicebusConnection, entityPath, mode)
{
this.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(this.ServiceBusConnection.SasKeyName, this.ServiceBusConnection.SasKey);
this.CbsTokenProvider = new TokenProviderAdapter(this.TokenProvider, this.ServiceBusConnection.OperationTimeout);
}
/// <inheritdoc />
public virtual IServiceBusHostBuilder UseTokenProvider(TokenProvider value)
{
_hostConfiguratorActions.Add(configure => configure.TokenProvider = value);
return(this);
}
public async void Should_be_configured_and_working()
{
var settings = new TestAzureServiceBusAccountSettings();
var provider = new SharedAccessKeyTokenProvider(settings);
TokenProvider tokenProvider = provider.GetTokenProvider();
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build",
"MassTransit.AzureServiceBusTransport.Tests");
var namespaceManager = new NamespaceManager(serviceUri, tokenProvider);
CreateQueue(namespaceManager, serviceUri, "TestClient");
CreateHostQueue(tokenProvider);
var mfs = new MessagingFactorySettings
{
TokenProvider = tokenProvider,
OperationTimeout = TimeSpan.FromSeconds(30),
TransportType = TransportType.Amqp,
AmqpTransportSettings = new AmqpTransportSettings
{
BatchFlushInterval = TimeSpan.FromMilliseconds(50),
},
};
MessagingFactory factory =
MessagingFactory.Create(
ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build", Environment.MachineName), mfs);
MessageReceiver receiver = await factory.CreateMessageReceiverAsync("Control");
receiver.PrefetchCount = 100;
var done = new TaskCompletionSource <bool>();
int count = 0;
const int limit = 1000;
receiver.OnMessageAsync(async message =>
{
var receiveContext = new ServiceBusReceiveContext(new Uri("sb://localhost/queue"), message, new ReceiveObservable());
await message.CompleteAsync();
int received = Interlocked.Increment(ref count);
if (received == limit)
{
done.TrySetResult(true);
}
}, new OnMessageOptions
{
AutoComplete = false,
MaxConcurrentCalls = 100,
AutoRenewTimeout = TimeSpan.FromSeconds(60),
});
MessageSender client = await factory.CreateMessageSenderAsync("Control");
Stopwatch stopwatch = Stopwatch.StartNew();
Task[] tasks = new Task[limit];
for (int i = 0; i < limit; i++)
{
tasks[i] = SendAMessage(client);
}
await done.Task;
stopwatch.Stop();
await Task.WhenAll(tasks);
await receiver.CloseAsync();
Console.WriteLine("Performance: {0:F2}/s", limit * 1000 / stopwatch.ElapsedMilliseconds);
}
public SignalRController(EndpointProvider endpointProvider, TokenProvider tokenProvider)
{
_endpointProvider = endpointProvider;
_tokenProvider = tokenProvider;
}
static void Run()
{
var properties = new Dictionary <string, string>
{
{ servicebusNamespace, null },
{ servicebusEntityPath, null },
{ servicebusFqdnSuffix, null },
{ servicebusSendKey, null },
{ servicebusListenKey, null },
{ servicebusManageKey, null }
};
// read the settings file created by the ./setup.ps1 file
var settingsFile = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
samplePropertiesFileName);
if (File.Exists(settingsFile))
{
using (var fs = new StreamReader(settingsFile))
{
while (!fs.EndOfStream)
{
var readLine = fs.ReadLine();
if (readLine != null)
{
var propl = readLine.Trim();
var cmt = propl.IndexOf('#');
if (cmt > -1)
{
propl = propl.Substring(0, cmt).Trim();
}
if (propl.Length > 0)
{
var propi = propl.IndexOf('=');
if (propi == -1)
{
continue;
}
var propKey = propl.Substring(0, propi - 1).Trim();
var propVal = propl.Substring(propi + 1).Trim();
if (properties.ContainsKey(propKey))
{
properties[propKey] = propVal;
}
}
}
}
}
}
// get overrides from the environment
var keys = new List <string>(properties.Keys);
foreach (var key in keys)
{
var env = Environment.GetEnvironmentVariable(key);
if (env != null)
{
properties[key] = env;
}
}
var hostName = properties[servicebusNamespace] + "." + properties[servicebusFqdnSuffix];
var rootUri = new UriBuilder("http", hostName, -1, "/").ToString();
var netTcpUri = new UriBuilder("sb", hostName, -1, properties[servicebusEntityPath] + "/NetTcp").ToString();
var httpUri = new UriBuilder("https", hostName, -1, properties[servicebusEntityPath] + "/Http").ToString();
var program = Activator.CreateInstance(typeof(Program));
if (program is ITcpListenerSampleUsingKeys)
{
((ITcpListenerSampleUsingKeys)program).Run(
netTcpUri,
"samplelisten",
properties[servicebusListenKey])
.GetAwaiter()
.GetResult();
}
else if (program is ITcpSenderSampleUsingKeys)
{
((ITcpSenderSampleUsingKeys)program).Run(netTcpUri, "samplesend", properties[servicebusSendKey])
.GetAwaiter()
.GetResult();
}
if (program is IHttpListenerSampleUsingKeys)
{
((IHttpListenerSampleUsingKeys)program).Run(
httpUri,
"samplelisten",
properties[servicebusListenKey])
.GetAwaiter()
.GetResult();
}
else if (program is IHttpSenderSampleUsingKeys)
{
((IHttpSenderSampleUsingKeys)program).Run(httpUri, "samplesend", properties[servicebusSendKey])
.GetAwaiter()
.GetResult();
}
if (program is ITcpListenerSample)
{
var token =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
"samplelisten",
properties[servicebusListenKey])
.GetWebTokenAsync(netTcpUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((ITcpListenerSample)program).Run(netTcpUri, token).GetAwaiter().GetResult();
}
else if (program is ITcpSenderSample)
{
var token =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
"samplesend",
properties[servicebusSendKey])
.GetWebTokenAsync(netTcpUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((ITcpSenderSample)program).Run(netTcpUri, token).GetAwaiter().GetResult();
}
if (program is IHttpListenerSample)
{
var token =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
"samplelisten",
properties[servicebusListenKey])
.GetWebTokenAsync(httpUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IHttpListenerSample)program).Run(httpUri, token).GetAwaiter().GetResult();
}
else if (program is IHttpSenderSample)
{
var token =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
"samplesend",
properties[servicebusSendKey])
.GetWebTokenAsync(httpUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IHttpSenderSample)program).Run(httpUri, token).GetAwaiter().GetResult();
}
else if (program is IDynamicSenderSample)
{
var token =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
"rootsamplesend",
properties[servicebusSendKey])
.GetWebTokenAsync(rootUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDynamicSenderSample)program).Run(hostName, token).GetAwaiter().GetResult();
}
else if (program is IDynamicListenerSample)
{
var token =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
"rootsamplelisten",
properties[servicebusListenKey])
.GetWebTokenAsync(rootUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDynamicListenerSample)program).Run(hostName, token).GetAwaiter().GetResult();
}
else if (program is IDynamicSample)
{
var token =
TokenProvider.CreateSharedAccessSignatureTokenProvider(
"rootsamplemanage",
properties[servicebusManageKey])
.GetWebTokenAsync(rootUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
((IDynamicSample)program).Run(hostName, token).GetAwaiter().GetResult();
}
else if (program is IConnectionStringSample)
{
var connectionString =
ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
new Uri(rootUri), "rootsamplemanage",
properties[servicebusManageKey]);
((IConnectionStringSample)program).Run(connectionString).GetAwaiter().GetResult();
}
}
private async void btnStart_Click(object sender, EventArgs e)
{
try
{
if (string.Compare(btnStart.Text, Start, StringComparison.OrdinalIgnoreCase) == 0)
{
// Change button text
btnStart.Text = Stop;
// Validate parameters
if (!ValidateParameters())
{
return;
}
// Create namespace manager
var namespaceUri = ServiceBusEnvironment.CreateServiceUri("sb", txtNamespace.Text, string.Empty);
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(txtKeyName.Text, txtKeyValue.Text);
var namespaceManager = new NamespaceManager(namespaceUri, tokenProvider);
// Check if the event hub already exists, if not, create the event hub.
var eventHubDescription = await namespaceManager.EventHubExistsAsync(txtEventHub.Text) ?
await namespaceManager.GetEventHubAsync(txtEventHub.Text) :
await namespaceManager.CreateEventHubAsync(new EventHubDescription(txtEventHub.Text)
{
PartitionCount = txtPartitionCount.IntegerValue,
MessageRetentionInDays = txtMessageRetentionInDays.IntegerValue
});
WriteToLog(string.Format(EventHubCreatedOrRetrieved, txtEventHub.Text));
// Check if the SAS authorization rule used by devices to send events to the event hub already exists, if not, create the rule.
var authorizationRule = eventHubDescription.
Authorization.
FirstOrDefault(r => string.Compare(r.KeyName,
SenderSharedAccessKey,
StringComparison.InvariantCultureIgnoreCase)
== 0) as SharedAccessAuthorizationRule;
if (authorizationRule == null)
{
authorizationRule = new SharedAccessAuthorizationRule(SenderSharedAccessKey,
SharedAccessAuthorizationRule.GenerateRandomKey(),
new[]
{
AccessRights.Send
});
eventHubDescription.Authorization.Add(authorizationRule);
await namespaceManager.UpdateEventHubAsync(eventHubDescription);
}
cancellationTokenSource = new CancellationTokenSource();
var serviceBusNamespace = txtNamespace.Text;
var eventHubName = txtEventHub.Text;
var senderKey = authorizationRule.PrimaryKey;
var status = txtStatus.Text;
var eventInterval = txtEventIntervalInMilliseconds.IntegerValue;
var minValue = txtMinValue.IntegerValue;
var maxValue = txtMaxValue.IntegerValue;
var cancellationToken = cancellationTokenSource.Token;
// Create one task for each device
for (var i = 1; i <= txtDeviceCount.IntegerValue; i++)
{
var deviceId = i;
#pragma warning disable 4014
#pragma warning disable 4014
Task.Run(async() =>
#pragma warning restore 4014
{
var deviceName = $"device{deviceId:000}";
var random = new Random((int)DateTime.Now.Ticks);
if (radioButtonAmqp.Checked)
{
// The token has the following format:
// SharedAccessSignature sr={URI}&sig={HMAC_SHA256_SIGNATURE}&se={EXPIRATION_TIME}&skn={KEY_NAME}
var token = CreateSasTokenForAmqpSender(SenderSharedAccessKey,
senderKey,
serviceBusNamespace,
eventHubName,
deviceName,
TimeSpan.FromDays(1));
WriteToLog(string.Format(SasToken, deviceId));
var messagingFactory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, ""), new MessagingFactorySettings
{
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(token),
TransportType = TransportType.Amqp
});
WriteToLog(string.Format(MessagingFactoryCreated, deviceId));
// Each device uses a different publisher endpoint: [EventHub]/publishers/[PublisherName]
var eventHubClient = messagingFactory.CreateEventHubClient($"{eventHubName}/publishers/{deviceName}");
WriteToLog(string.Format(EventHubClientCreated, deviceId, eventHubClient.Path));
while (!cancellationToken.IsCancellationRequested)
{
// Create random value
var value = random.Next(minValue, maxValue + 1);
// Create EventData object with the payload serialized in JSON format
var payload = JsonConvert.SerializeObject(new Payload
{
Id = deviceId,
Name = deviceName,
Status = status,
Value = value
});
using (var eventData = new EventData(Encoding.UTF8.GetBytes(payload))
{
PartitionKey = deviceName
})
{
// Create custom properties
eventData.Properties.Add(DeviceId, deviceId);
eventData.Properties.Add(DeviceName, deviceName);
eventData.Properties.Add(DeviceLocation, status);
eventData.Properties.Add(Value, value);
// Send the event to the event hub
await eventHubClient.SendAsync(eventData);
WriteToLog(string.Format(EventSent, deviceId, deviceName, value));
}
// Wait for the event time interval
Thread.Sleep(eventInterval);
}
}
else
{
// The token has the following format:
// SharedAccessSignature sr={URI}&sig={HMAC_SHA256_SIGNATURE}&se={EXPIRATION_TIME}&skn={KEY_NAME}
var token = CreateSasTokenForHttpsSender(SenderSharedAccessKey,
senderKey,
serviceBusNamespace,
eventHubName,
deviceName,
TimeSpan.FromDays(1));
WriteToLog(string.Format(SasToken, deviceId));
// Create HttpClient object used to send events to the event hub.
var httpClient = new HttpClient
{
BaseAddress = new Uri($"https://{serviceBusNamespace}.servicebus.windows.net/{eventHubName}/publishers/{deviceName}".ToLower())
};
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", token);
httpClient.DefaultRequestHeaders.Add("ContentType", "application/json;type=entry;charset=utf-8");
WriteToLog(string.Format(HttpClientCreated, deviceId, httpClient.BaseAddress));
while (!cancellationToken.IsCancellationRequested)
{
// Create random value
var value = random.Next(minValue, maxValue + 1);
// Create HttpContent
var postContent = new ByteArrayContent(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new Payload
{
Id = deviceId,
Name = deviceName,
Status = status,
Value = value
})));
// Create custom properties
postContent.Headers.Add(DeviceId, deviceId.ToString(CultureInfo.InvariantCulture));
postContent.Headers.Add(DeviceName, deviceName);
//postContent.Headers.Add(DeviceLocation, location);
postContent.Headers.Add(Value, value.ToString(CultureInfo.InvariantCulture));
try
{
var response = await httpClient.PostAsync(httpClient.BaseAddress + "/messages" + "?timeout=60" + ApiVersion, postContent, cancellationToken);
response.EnsureSuccessStatusCode();
WriteToLog(string.Format(EventSent, deviceId, deviceName, value));
}
catch (HttpRequestException ex)
{
WriteToLog(string.Format(SendFailed, deviceId, ex.Message));
}
}
}
},
cancellationToken).ContinueWith(t =>
#pragma warning restore 4014
#pragma warning restore 4014
{
if (t.IsFaulted && t.Exception != null)
{
HandleException(t.Exception);
}
}, cancellationToken);
}
}
else
{
// Change button text
btnStart.Text = Start;
cancellationTokenSource?.Cancel();
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
public async Task Logout()
{
await TokenProvider.SetTokenAsync(null);
AtaAuthenticationStateProvider.StateHasChanged();
}
public TokenProvider GetTokenProvider()
{
return(TokenProvider.CreateSharedAccessSignatureTokenProvider(_settings.KeyName, _settings.SharedAccessKey,
_settings.TokenTimeToLive, _settings.TokenScope));
}
public async Task Run(
string namespaceAddress,
string basicQueueName,
string basicQueue2Name,
string sendKeyName,
string sendKey,
string receiveKeyName,
string receiveKey)
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(sendKeyName, sendKey);
var primaryFactory = MessagingFactory.Create(
namespaceAddress,
new MessagingFactorySettings {
TokenProvider = tokenProvider, TransportType = TransportType.Amqp
});
var secondaryFactory = MessagingFactory.Create(
namespaceAddress,
new MessagingFactorySettings {
TokenProvider = tokenProvider, TransportType = TransportType.Amqp
});
this.activeQueueClient = primaryFactory.CreateQueueClient(basicQueueName);
this.backupQueueClient = secondaryFactory.CreateQueueClient(basicQueue2Name);
try
{
// Create a primary and secondary queue client.
// forcing an error after 5 seconds by taking down the primary factory
// usually, errors will be more transient
#pragma warning disable 4014
Task.Delay(5000).ContinueWith(
t => primaryFactory.Abort()
);
#pragma warning restore 4014
Console.WriteLine("\nSending messages to primary or secondary queue...\n");
for (var i = 1; i <= 500; i++)
{
// Create brokered message.
var message = new BrokeredMessage("Message" + i)
{
MessageId = i.ToString(),
TimeToLive = TimeSpan.FromMinutes(2.0)
};
var m1 = message;
try
{
await this.SendMessage(m1);
}
catch (Exception e)
{
Console.WriteLine("Unable to send to primary or secondary queue: Exception {0}", e);
}
}
Console.WriteLine("\nPress ENTER to clean up and exit.");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("Unexpected exception {0}", e);
throw;
}
finally
{
// Closing factories closes all entities created from these factories.
primaryFactory?.Close();
secondaryFactory?.Close();
}
}
