Exemplo n.º 1
0
        private static TokenProvider CreateTokenProvider(IEnumerable <Uri> stsEndpoints, string issuerName, string issuerKey, string sharedAccessKeyName, string sharedAccessKey, string windowsDomain, string windowsUser, SecureString windowsPassword, string oauthDomain, string oauthUser, SecureString oauthPassword)
        {
            if (!string.IsNullOrWhiteSpace(sharedAccessKey))
            {
                return(TokenProvider.CreateSharedAccessSignatureTokenProvider(sharedAccessKeyName, sharedAccessKey));
            }
            if (!string.IsNullOrWhiteSpace(issuerName))
            {
                if (stsEndpoints == null || !stsEndpoints.Any <Uri>())
                {
                    return(TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerKey));
                }
                return(TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerKey, stsEndpoints.First <Uri>()));
            }
            bool flag  = (stsEndpoints == null ? false : stsEndpoints.Any <Uri>());
            bool flag1 = (string.IsNullOrWhiteSpace(windowsUser) || windowsPassword == null ? false : windowsPassword.Length > 0);
            bool flag2 = (string.IsNullOrWhiteSpace(oauthUser) || oauthPassword == null ? false : oauthPassword.Length > 0);

            if (!flag)
            {
                return(null);
            }
            if (flag2)
            {
                return(TokenProvider.CreateOAuthTokenProvider(stsEndpoints, (string.IsNullOrWhiteSpace(oauthDomain) ? new NetworkCredential(oauthUser, oauthPassword) : new NetworkCredential(oauthUser, oauthPassword, oauthDomain))));
            }
            if (!flag1)
            {
                return(TokenProvider.CreateWindowsTokenProvider(stsEndpoints));
            }
            return(TokenProvider.CreateWindowsTokenProvider(stsEndpoints, (string.IsNullOrWhiteSpace(windowsDomain) ? new NetworkCredential(windowsUser, windowsPassword) : new NetworkCredential(windowsUser, windowsPassword, windowsDomain))));
        }
Exemplo n.º 2
0
        static void Main(string[] args)
        {
            Console.WriteLine("Connecting");
            var _messagingFactory = MessagingFactory.Create();
            var _namespaceManager = NamespaceManager.Create();

            Console.WriteLine("Creating Provider");
            var provider = TokenProvider.CreateOAuthTokenProvider(new Uri[] { new Uri("https://richlaisbhost:9355/ServiceBusDefaultNamespace") }, new NetworkCredential("richard.lai", "I.am.a.pirate101"));

            Console.WriteLine("Setting NS Provider");
            _namespaceManager.Settings.TokenProvider = provider;

            Console.WriteLine("Setting MF Provider");
            _messagingFactory.GetSettings().TokenProvider = provider;

            Console.WriteLine("Checking");
            if (!_namespaceManager.QueueExists("MyQueue"))
            {
                Console.WriteLine("Creating");
                _namespaceManager.CreateQueue("MyQueue");
            }

            QueueClient client = _messagingFactory.CreateQueueClient("MyQueue");

            client.Send(new BrokeredMessage("aha"));

            Console.WriteLine("Finished");
        }
Exemplo n.º 3
0
        /// <summary>
        /// Create new client for servicebus connection. This method is slow!
        /// </summary>
        /// <param name="connectionString">Connection string</param>
        /// <param name="operationTimeoutForClients">Operation timeout for clients</param>
        /// <returns>Object that can handle messaging to the service bus</returns>
        internal static MessagingFactory CreateMessagingFactoryWithTimeout(string connectionString, TimeSpan operationTimeoutForClients)
        {
            var connBuilder     = new ServiceBusConnectionStringBuilder(connectionString);
            var factorySettings = new MessagingFactorySettings
            {
                OperationTimeout = operationTimeoutForClients
            };

            if (connBuilder.SharedAccessKey != null)
            {
                factorySettings.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(connBuilder.SharedAccessKeyName, connBuilder.SharedAccessKey);
            }
            else if (connBuilder.SharedSecretIssuerName != null)
            {
                factorySettings.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(connBuilder.SharedSecretIssuerName, connBuilder.SharedSecretIssuerSecret);
            }
            else if (connBuilder.OAuthUsername != null)
            {
                if (!string.IsNullOrEmpty(connBuilder.OAuthDomain))
                {
                    TokenProvider.CreateOAuthTokenProvider(connBuilder.StsEndpoints,
                                                           new NetworkCredential(connBuilder.OAuthUsername,
                                                                                 connBuilder.OAuthPassword,
                                                                                 connBuilder.OAuthDomain));
                }
                else
                {
                    TokenProvider.CreateOAuthTokenProvider(connBuilder.StsEndpoints,
                                                           new NetworkCredential(connBuilder.OAuthUsername,
                                                                                 connBuilder.OAuthPassword));
                }
            }
            else if (connBuilder.StsEndpoints.Count > 0)
            {
                factorySettings.TokenProvider = TokenProvider.CreateWindowsTokenProvider(connBuilder.StsEndpoints);
            }


            factorySettings.EnableAdditionalClientTimeout = true;

            MessagingFactory messageFactory = MessagingFactory.Create(connBuilder.GetAbsoluteRuntimeEndpoints(), factorySettings);

            messageFactory.RetryPolicy = RetryPolicy.Default;

            return(messageFactory);
        }