public HttpClientCacheKey(TimeSpan timeout, OperationCredentials credentials)
{
Timeout = timeout;
Credentials = credentials != null ? credentials.Credentials : null;
ApiKey = credentials != null ? credentials.ApiKey : null;
AuthenticationDisabled = credentials == null;
}
internal static async Task<RavenJObject> GetMetadataForAsyncImpl(IHoldProfilingInformation self, HttpJsonRequestFactory requestFactory, FilesConvention conventions,
NameValueCollection operationsHeaders, string filename, string baseUrl, OperationCredentials credentials)
{
using (var request = requestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(self, baseUrl + "/files?name=" + Uri.EscapeDataString(filename), "HEAD", credentials, conventions)).AddOperationHeaders(operationsHeaders))
{
try
{
await request.ExecuteRequestAsync().ConfigureAwait(false);
var response = request.Response;
var metadata = response.HeadersToObject();
metadata[Constants.MetadataEtagField] = metadata[Constants.MetadataEtagField].Value<string>().Trim('\"');
return metadata;
}
catch (Exception e)
{
try
{
throw e.SimplifyException();
}
catch (FileNotFoundException)
{
return null;
}
}
}
}
internal HttpJsonRequest(
CreateHttpJsonRequestParams requestParams,
HttpJsonRequestFactory factory)
{
_credentials = requestParams.Credentials;
Url = requestParams.Url;
this.factory = factory;
owner = requestParams.Owner;
conventions = requestParams.Convention;
Method = requestParams.Method;
webRequest = (HttpWebRequest)WebRequest.Create(requestParams.Url);
webRequest.UseDefaultCredentials = true;
webRequest.Credentials = requestParams.Credentials.Credentials;
webRequest.Method = requestParams.Method;
if (factory.DisableRequestCompression == false && requestParams.DisableRequestCompression == false)
{
if (requestParams.Method == "POST" || requestParams.Method == "PUT" ||
requestParams.Method == "PATCH" || requestParams.Method == "EVAL")
webRequest.Headers["Content-Encoding"] = "gzip";
webRequest.Headers["Accept-Encoding"] = "gzip";
}
webRequest.ContentType = "application/json; charset=utf-8";
webRequest.Headers.Add("Raven-Client-Version", ClientVersion);
WriteMetadata(requestParams.Metadata);
requestParams.UpdateHeaders(webRequest);
}
internal static async Task<Stream> DownloadAsyncImpl(IHoldProfilingInformation self, HttpJsonRequestFactory requestFactory, FilesConvention conventions,
NameValueCollection operationsHeaders, string path, string filename, Reference<RavenJObject> metadataRef, long? @from, long? to, string baseUrl, OperationCredentials credentials)
{
var request = requestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(self, baseUrl + path + Uri.EscapeDataString(filename), "GET", credentials, conventions)).AddOperationHeaders(operationsHeaders);
if (@from != null)
{
if (to != null)
request.AddRange(@from.Value, to.Value);
else
request.AddRange(@from.Value);
}
try
{
var response = await request.ExecuteRawResponseAsync().ConfigureAwait(false);
if (response.StatusCode == HttpStatusCode.NotFound)
throw new FileNotFoundException("The file requested does not exists on the file system.", baseUrl + path + filename);
await response.AssertNotFailingResponse().ConfigureAwait(false);
if (metadataRef != null)
metadataRef.Value = response.HeadersToObject();
return new DisposableStream(await response.GetResponseStreamWithHttpDecompression().ConfigureAwait(false), request.Dispose);
}
catch (Exception e)
{
throw e.SimplifyException();
}
}
public CreateHttpJsonRequestParams(IHoldProfilingInformation self, string url, string method, RavenJObject metadata, OperationCredentials credentials, DocumentConvention convention)
{
Owner = self;
Url = url;
Method = method;
Metadata = metadata;
Credentials = credentials;
Convention = convention;
operationsHeadersCollection = new NameValueCollection();
}
public OperationMetadata(string url, string username = null, string password = null, string domain = null, string apiKey = null)
{
Url = url;
ICredentials credentials = null;
if (!string.IsNullOrEmpty(username))
credentials = new NetworkCredential(username, password ?? string.Empty, domain ?? string.Empty);
Credentials = new OperationCredentials(apiKey, credentials);
}
private const int DefaultNumberOfCachedRequests = 2048; //put this in asyncserverclient
public SynchronizationServerClient(string serverUrl, string fileSystem, string apiKey, ICredentials credentials, FilesConvention convention = null,
OperationCredentials operationCredentials = null, HttpJsonRequestFactory requestFactory = null, NameValueCollection operationsHeaders = null)
{
serverUrl = serverUrl.TrimEnd('/');
baseUrl = serverUrl + "/fs/" + Uri.EscapeDataString(fileSystem);
credentials = credentials ?? CredentialCache.DefaultNetworkCredentials;
this.filesConvention = convention ?? new FilesConvention();
this.operationCredentials = operationCredentials ?? new OperationCredentials(apiKey, credentials);
this.requestFactory = requestFactory ?? new HttpJsonRequestFactory(DefaultNumberOfCachedRequests);
this.OperationsHeaders = operationsHeaders ?? new NameValueCollection();
SecurityExtensions.InitializeSecurity(Conventions, RequestFactory, serverUrl, credentials);
}
public HttpClient GetClient(TimeSpan timeout, OperationCredentials credentials, Func<HttpMessageHandler> handlerFactory)
{
var key = new HttpClientCacheKey(timeout, credentials);
var queue = cache.GetOrAdd(key, i => new ConcurrentQueue<HttpClient>());
HttpClient client;
if (queue.TryDequeue(out client))
{
client.CancelPendingRequests();
client.DefaultRequestHeaders.Clear();
return client;
}
return new HttpClient(handlerFactory())
{
Timeout = timeout
};
}
public HttpClient GetClient(TimeSpan timeout, OperationCredentials credentials, Func<HttpMessageHandler> handlerFactory)
{
var key = new HttpClientCacheKey(timeout, credentials);
var queue = cache.GetOrAdd(key, i => new ConcurrentQueue<Tuple<long, HttpClient>>());
Tuple<long, HttpClient> client;
while (queue.TryDequeue(out client))
{
if (Stopwatch.GetTimestamp() - client.Item1 > _maxIdleTime)
{
client.Item2.Dispose();
continue;
}
client.Item2.CancelPendingRequests();
client.Item2.DefaultRequestHeaders.Clear();
return client.Item2;
}
return new HttpClient(handlerFactory())
{
Timeout = timeout
};
}
public OperationMetadata(OperationMetadata operationMetadata)
{
Url = operationMetadata.Url;
Credentials = new OperationCredentials(operationMetadata.Credentials.ApiKey, operationMetadata.Credentials.Credentials);
}
public OperationMetadata(string url, OperationCredentials credentials)
{
Url = url;
Credentials = credentials != null ? new OperationCredentials(credentials.ApiKey, credentials.Credentials) : new OperationCredentials(null,null);
}
public OperationMetadata(string url, ICredentials credentials, string apiKey = null)
{
Url = url;
Credentials = new OperationCredentials(apiKey, credentials);
}
public static HttpJsonRequest ToJsonRequest(this string url, AsyncServerClient requestor, OperationCredentials credentials, DocumentConvention convention, IDictionary<string, string> operationsHeaders, string method)
{
var httpJsonRequest = requestor.jsonRequestFactory.CreateHttpJsonRequest(
new CreateHttpJsonRequestParams(requestor, url, method, credentials, convention)
.AddOperationHeaders(operationsHeaders));
return httpJsonRequest;
}
public static HttpJsonRequest ToJsonRequest(this string url, AsyncServerClient requestor, OperationCredentials credentials, Document.DocumentConvention convention)
{
return requestor.jsonRequestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(requestor, url, "GET", credentials, convention));
}
public CounterBatch(RavenCountersClient countersClient, CounterConvention convention)
{
credentials = countersClient.PrimaryCredentials;
jsonRequestFactory = countersClient.JsonRequestFactory;
counterStorageUrl = countersClient.CounterStorageUrl;
this.convention = convention;
}
public void ReleaseClient(HttpClient client, OperationCredentials credentials)
{
var key = new HttpClientCacheKey(client.Timeout, credentials);
var queue = cache.GetOrAdd(key, i => new ConcurrentQueue<Tuple<long, HttpClient>>());
queue.Enqueue(Tuple.Create(Stopwatch.GetTimestamp(), client));
}
public CreateHttpJsonRequestParams(IHoldProfilingInformation self, string url, string method, OperationCredentials credentials, DocumentConvention convention)
: this(self, url, method, new RavenJObject(), credentials, convention)
{
}
public void ReleaseClient(HttpClient client, OperationCredentials credentials)
{
var key = new HttpClientCacheKey(client.Timeout, credentials);
var queue = cache.GetOrAdd(key, i => new ConcurrentQueue<HttpClient>());
queue.Enqueue(client);
}
private void InitializeSecurity()
{
if (convention.HandleUnauthorizedResponseAsync != null)
return; // already setup by the user
if (string.IsNullOrEmpty(ApiKey) == false)
{
Credentials = null;
}
credentialsThatShouldBeUsedOnlyInOperationsWithoutReplication = new OperationCredentials(ApiKey, Credentials);
var basicAuthenticator = new BasicAuthenticator(JsonRequestFactory.EnableBasicAuthenticationOverUnsecuredHttpEvenThoughPasswordsWouldBeSentOverTheWireInClearTextToBeStolenByHackers);
var securedAuthenticator = new SecuredAuthenticator();
JsonRequestFactory.ConfigureRequest += basicAuthenticator.ConfigureRequest;
JsonRequestFactory.ConfigureRequest += securedAuthenticator.ConfigureRequest;
convention.HandleForbiddenResponseAsync = (forbiddenResponse, credentials) =>
{
if (credentials.ApiKey == null)
{
AssertForbiddenCredentialSupportWindowsAuth(forbiddenResponse);
return null;
}
return null;
};
convention.HandleUnauthorizedResponseAsync = (unauthorizedResponse, credentials) =>
{
var oauthSource = unauthorizedResponse.Headers.GetFirstValue("OAuth-Source");
#if DEBUG && FIDDLER
// Make sure to avoid a cross DNS security issue, when running with Fiddler
if (string.IsNullOrEmpty(oauthSource) == false)
oauthSource = oauthSource.Replace("localhost:", "localhost.fiddler:");
#endif
// Legacy support
if (string.IsNullOrEmpty(oauthSource) == false &&
oauthSource.EndsWith("/OAuth/API-Key", StringComparison.CurrentCultureIgnoreCase) == false)
{
return basicAuthenticator.HandleOAuthResponseAsync(oauthSource, credentials.ApiKey);
}
if (credentials.ApiKey == null)
{
AssertUnauthorizedCredentialSupportWindowsAuth(unauthorizedResponse, credentials.Credentials);
return null;
}
if (string.IsNullOrEmpty(oauthSource))
oauthSource = ServerUrl + "/OAuth/API-Key";
return securedAuthenticator.DoOAuthRequestAsync(ServerUrl, oauthSource, credentials.ApiKey);
};
}
public CreateHttpJsonRequestParams(IHoldProfilingInformation self, string url, string method, OperationCredentials credentials, Convention convention, TimeSpan? timeout = null)
: this(self, url, method, new RavenJObject(), credentials, convention, timeout)
{}
public AdminClient(RavenCountersClient countersClient, CounterConvention convention)
{
credentials = countersClient.PrimaryCredentials;
jsonRequestFactory = countersClient.JsonRequestFactory;
serverUrl = countersClient.ServerUrl;
counterStorageName = countersClient.CounterStorageName;
this.convention = convention;
}
public HttpClient GetClient(TimeSpan timeout, OperationCredentials credentials, Func<HttpMessageHandler> handlerFactory)
{
var key = new HttpClientCacheKey(timeout, credentials);
var stack = cache.GetOrAdd(key, i => new ConcurrentStack<Tuple<long, HttpClient>>());
Tuple<long, HttpClient> client;
while (stack.TryPop(out client))
{
if (IsClientTooOld(client.Item1))
{
client.Item2.Dispose();
continue;
}
client.Item2.CancelPendingRequests();
client.Item2.DefaultRequestHeaders.Clear();
return client.Item2;
}
return new HttpClient(handlerFactory())
{
Timeout = timeout
};
}
