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