public GatewayAddressCache(
Uri serviceEndpoint,
Protocol protocol,
IAuthorizationTokenProvider tokenProvider,
UserAgentContainer userAgent,
IServiceConfigurationReader serviceConfigReader,
long suboptimalPartitionForceRefreshIntervalInSeconds = 600,
HttpMessageHandler messageHandler = null,
ApiType apiType = ApiType.None)
{
this.addressEndpoint = new Uri(serviceEndpoint + "/" + Paths.AddressPathSegment);
this.protocol = protocol;
this.tokenProvider = tokenProvider;
this.serviceEndpoint = serviceEndpoint;
this.serviceConfigReader = serviceConfigReader;
this.serverPartitionAddressCache = new AsyncCache <PartitionKeyRangeIdentity, PartitionAddressInformation>();
this.suboptimalServerPartitionTimestamps = new ConcurrentDictionary <PartitionKeyRangeIdentity, DateTime>();
this.suboptimalMasterPartitionTimestamp = DateTime.MaxValue;
this.suboptimalPartitionForceRefreshIntervalInSeconds = suboptimalPartitionForceRefreshIntervalInSeconds;
this.httpClient = messageHandler == null ? new HttpClient() : new HttpClient(messageHandler);
this.protocolFilter =
string.Format(CultureInfo.InvariantCulture,
GatewayAddressCache.protocolFilterFormat,
Constants.Properties.Protocol,
GatewayAddressCache.ProtocolString(this.protocol));
// Set requested API version header for version enforcement.
this.httpClient.DefaultRequestHeaders.Add(HttpConstants.HttpHeaders.Version,
HttpConstants.Versions.CurrentVersion);
this.httpClient.AddUserAgentHeader(userAgent);
this.httpClient.AddApiTypeHeader(apiType);
}
public GatewayAddressCache(
Uri serviceEndpoint,
Protocol protocol,
IAuthorizationTokenProvider tokenProvider,
IServiceConfigurationReader serviceConfigReader,
CosmosHttpClient httpClient,
long suboptimalPartitionForceRefreshIntervalInSeconds = 600,
bool enableTcpConnectionEndpointRediscovery = false)
{
this.addressEndpoint = new Uri(serviceEndpoint + "/" + Paths.AddressPathSegment);
this.protocol = protocol;
this.tokenProvider = tokenProvider;
this.serviceEndpoint = serviceEndpoint;
this.serviceConfigReader = serviceConfigReader;
this.serverPartitionAddressCache = new AsyncCache <PartitionKeyRangeIdentity, PartitionAddressInformation>();
this.suboptimalServerPartitionTimestamps = new ConcurrentDictionary <PartitionKeyRangeIdentity, DateTime>();
this.serverPartitionAddressToPkRangeIdMap = new ConcurrentDictionary <ServerKey, HashSet <PartitionKeyRangeIdentity> >();
this.suboptimalMasterPartitionTimestamp = DateTime.MaxValue;
this.enableTcpConnectionEndpointRediscovery = enableTcpConnectionEndpointRediscovery;
this.suboptimalPartitionForceRefreshIntervalInSeconds = suboptimalPartitionForceRefreshIntervalInSeconds;
this.httpClient = httpClient;
this.protocolFilter =
string.Format(CultureInfo.InvariantCulture,
GatewayAddressCache.protocolFilterFormat,
Constants.Properties.Protocol,
GatewayAddressCache.ProtocolString(this.protocol));
}
public PartitionKeyRangeCache(IAuthorizationTokenProvider authorizationTokenProvider, IStoreModel storeModel, CollectionCache collectionCache)
{
this.routingMapCache = new AsyncCache <string, CollectionRoutingMap>(
EqualityComparer <CollectionRoutingMap> .Default,
StringComparer.Ordinal);
this.authorizationTokenProvider = authorizationTokenProvider;
this.storeModel = storeModel;
this.collectionCache = collectionCache;
}
/// <summary>
/// Create new instance of <see cref="HttpRequestContext"/>
/// </summary>
/// <param name="traceContext"></param>
public HttpRequestContext(TraceContext traceContext, IAuthorizationTokenProvider authorizationProvider, IHttpExtension httpExtension = null)
{
ArgumentValidator.ThrowIfNull(
traceContext,
nameof(traceContext));
this.TraceContext = traceContext;
this.AuthorizationProvider = authorizationProvider;
this.HttpExtension = httpExtension;
}
public UsernamePasswordAuthenticationService(
IUsernamePasswordAuthenticationProvider usernamePasswordAuthenticationProvider,
IPermissionAuthorizationProvider permissionAuthorizationProvider,
IAuthorizationTokenProvider authorizationTokenProvider
)
{
_usernamePasswordAuthenticationProvider = usernamePasswordAuthenticationProvider;
_permissionAuthorizationProvider = permissionAuthorizationProvider;
_authorizationTokenProvider = authorizationTokenProvider;
}
public ClientCollectionCache(IStoreModel storeModel, IAuthorizationTokenProvider tokenProvider, RetryPolicy retryPolicy)
{
if (storeModel == null)
{
throw new ArgumentNullException("storeModel");
}
this.storeModel = storeModel;
this.tokenProvider = tokenProvider;
this.retryPolicy = retryPolicy;
}
public AuthorizationController(IAuthorizationTokenProvider tokenProvider,
ICommandHandler <CreateUserCommand> userCommandHandler,
ISearchableRepository <UserInfo, UserInfo> searchRepository,
IHashProvider hashProvider,
IRepository <UserInfo, UserInfo> userRepository)
{
Condition.Requires(tokenProvider).IsNotNull();
Condition.Requires(userCommandHandler).IsNotNull();
Condition.Requires(searchRepository).IsNotNull();
Condition.Requires(hashProvider).IsNotNull();
Condition.Requires(userRepository).IsNotNull();
m_TokenProvider = tokenProvider;
m_UserCommandHandler = userCommandHandler;
m_SearchRepository = searchRepository;
m_HashProvider = hashProvider;
}
public void Test_ExchangeServiceThrowsOnEmptyTokenAndNullTokenProvider()
{
Assert.ThrowsException <ArgumentNullException>(() =>
{
ExchangeService exchangeService = new ExchangeService(
string.Empty,
"*****@*****.**");
});
Assert.ThrowsException <ArgumentNullException>(() =>
{
IAuthorizationTokenProvider provider = null;
ExchangeService exchangeService = new ExchangeService(
provider,
"*****@*****.**");
});
}
public UserCommandHandler(IHashProvider hashProvider,
IRepository <UserInfo, UserInfo> userRepository,
IMessager messager,
IAuthorizationTokenProvider tokenProvider,
ISearchableRepository <UserInfo, UserInfo> searchRepository)
{
Condition.Requires(tokenProvider).IsNotNull();
Condition.Requires(userRepository).IsNotNull();
Condition.Requires(hashProvider).IsNotNull();
Condition.Requires(messager).IsNotNull();
Condition.Requires(searchRepository).IsNotNull();
m_UserRepository = userRepository;
m_HashProvider = hashProvider;
m_Messager = messager;
m_TokenProvider = tokenProvider;
m_SearchRepository = searchRepository;
}
public UserController(IAuthorizationTokenProvider tokenProvider,
IRepository <UserInfo, UserInfo> userRepository,
ISearchableRepository <UserInfo, UserInfo> searchRepository,
ICommandHandler <ResetPasswordCommand> commandHandler,
ICommandHandler <SetPasswordCommand> setPasswordHandler)
{
Condition.Requires(tokenProvider).IsNotNull();
Condition.Requires(userRepository).IsNotNull();
Condition.Requires(commandHandler).IsNotNull();
Condition.Requires(searchRepository).IsNotNull();
Condition.Requires(setPasswordHandler).IsNotNull();
m_TokenProvider = tokenProvider;
m_UserRepository = userRepository;
m_CommandHandler = commandHandler;
m_SearchRepository = searchRepository;
m_SetPasswordHandler = setPasswordHandler;
}
public GlobalAddressResolver(
GlobalEndpointManager endpointManager,
Protocol protocol,
IAuthorizationTokenProvider tokenProvider,
CollectionCache collectionCache,
PartitionKeyRangeCache routingMapProvider,
UserAgentContainer userAgentContainer,
IServiceConfigurationReader serviceConfigReader,
HttpMessageHandler messageHandler,
ConnectionPolicy connectionPolicy,
ApiType apiType)
{
this.endpointManager = endpointManager;
this.protocol = protocol;
this.tokenProvider = tokenProvider;
this.userAgentContainer = userAgentContainer;
this.collectionCache = collectionCache;
this.routingMapProvider = routingMapProvider;
this.serviceConfigReader = serviceConfigReader;
this.messageHandler = messageHandler;
this.requestTimeout = connectionPolicy.RequestTimeout;
this.apiType = apiType;
int maxBackupReadEndpoints =
!connectionPolicy.EnableReadRequestsFallback.HasValue || connectionPolicy.EnableReadRequestsFallback.Value
? GlobalAddressResolver.MaxBackupReadRegions : 0;
this.enableTcpConnectionEndpointRediscovery = connectionPolicy.EnableTcpConnectionEndpointRediscovery;
this.maxEndpoints = maxBackupReadEndpoints + 2; // for write and alternate write endpoint (during failover)
this.addressCacheByEndpoint = new ConcurrentDictionary <Uri, EndpointCache>();
foreach (Uri endpoint in endpointManager.WriteEndpoints)
{
this.GetOrAddEndpoint(endpoint);
}
foreach (Uri endpoint in endpointManager.ReadEndpoints)
{
this.GetOrAddEndpoint(endpoint);
}
}
internal static Guid GetUserId(this HttpRequestMessage request)
{
try
{
string tokenHeader = request.Headers
.FirstOrDefault(header => header.Key == AUTH_TOKEN_NAME)
.Value.FirstOrDefault();
if (string.IsNullOrEmpty(tokenHeader))
{
throw new HttpException(401, ErrorMessages.UserNotAuthorized);
}
IAuthorizationTokenProvider tokenProvider = (IAuthorizationTokenProvider)WebApiConfig.Container.GetService(typeof(IAuthorizationTokenProvider));
Guid userId = tokenProvider.ValidateAuthorizationToken(tokenHeader);
return(userId);
}
catch (Exception)
{
throw new HttpException(401, ErrorMessages.UserNotAuthorized);
}
}
public StoreClient CreateStoreClient(
IAddressResolver addressResolver,
ISessionContainer sessionContainer,
IServiceConfigurationReader serviceConfigurationReader,
IAuthorizationTokenProvider authorizationTokenProvider,
bool enableRequestDiagnostics = false,
bool enableReadRequestsFallback = false,
bool useFallbackClient = true,
bool useMultipleWriteLocations = false)
{
this.ThrowIfDisposed();
if (useFallbackClient && this.fallbackClient != null)
{
return(new StoreClient(
addressResolver,
sessionContainer,
serviceConfigurationReader,
authorizationTokenProvider,
this.protocol,
// Use the fallback client instead of the default one.
this.fallbackClient,
enableRequestDiagnostics,
enableReadRequestsFallback,
useMultipleWriteLocations));
}
return(new StoreClient(
addressResolver,
sessionContainer,
serviceConfigurationReader,
authorizationTokenProvider,
this.protocol,
this.transportClient,
enableRequestDiagnostics,
enableReadRequestsFallback,
useMultipleWriteLocations));
}
public AuthorizationTokenRequestModifier(IAuthorizationTokenProvider authorizationTokenProvider)
{
this.authorizationTokenProvider = authorizationTokenProvider;
}
