|
public CreateHttpJsonRequest ( |
||
| createHttpJsonRequestParams | ||
| return | ||
public async Task Dictionary_with_empty_string_as_key_should_fail_bulk_insert_request()
{
var jsonRequestFactory = new HttpJsonRequestFactory(25);
using (var store = NewRemoteDocumentStore())
{
var url = String.Format("{0}/databases/{1}", store.Url, store.DefaultDatabase);
using (ConnectionOptions.Expect100Continue(url))
{
var operationUrl = "/bulkInsert?&operationId=" + Guid.NewGuid();
var createHttpJsonRequestParams = new CreateHttpJsonRequestParams(null, url + operationUrl, "POST", new OperationCredentials(String.Empty, CredentialCache.DefaultNetworkCredentials), new DocumentConvention());
var request = jsonRequestFactory.CreateHttpJsonRequest(createHttpJsonRequestParams);
var response = await request.ExecuteRawRequestAsync((requestStream, tcs) =>
{
using (var bufferedStream = new MemoryStream())
{
long bytesWritten;
WriteToBuffer(bufferedStream, out bytesWritten);
var requestBinaryWriter = new BinaryWriter(requestStream);
requestBinaryWriter.Write((int)bufferedStream.Position);
bufferedStream.WriteTo(requestStream);
requestStream.Flush();
tcs.TrySetResult(null);
}
});
Assert.Equal(422, (int)response.StatusCode);
}
}
}
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();
}
}
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;
}
}
}
}
public void Direct_request_with_empty_json_property_should_result_in_422_http_code()
{
//http://[DB url]/databases/[DB name]/bulk_docs
var httpRequestFactory = new HttpJsonRequestFactory(1);
const string body = "[{\"Key\":\"TestEntities/1\",\"Method\":\"PUT\",\"Document\":{\"Items\":{\"\":\"value for empty string\"}},\"Metadata\":{\"Raven-Entity-Name\":\"TestEntities\",\"Raven-Clr-Type\":\"Raven.Tests.Issues.RavenDB_3276+TestEntity, Raven.Tests.Issues\"},\"AdditionalData\":null,\"Etag\":\"00000000-0000-0000-0000-000000000000\"}]";
using (var store = NewRemoteDocumentStore())
{
var url = String.Format("{0}/databases/{1}/bulk_docs", store.Url, store.DefaultDatabase);
var request = httpRequestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(null, url, "POST", new OperationCredentials(null, CredentialCache.DefaultNetworkCredentials), new DocumentConvention()));
var exception = Assert.Throws<AggregateException>(() => request.WriteAsync(body).Wait());
var realException = exception.InnerException as ErrorResponseException;
Assert.Equal(422,(int)realException.StatusCode);
}
}
/// <summary>
/// Should execute the operation using the specified operation URL
/// </summary>
public virtual bool ShouldExecuteUsing(OperationMetadata operationMetadata, OperationMetadata primaryOperation, int currentRequest, string method, bool primary, Exception error, CancellationToken token)
{
if (primary == false)
{
AssertValidOperation(method, error);
}
var failureCounter = GetHolder(operationMetadata.Url);
if (failureCounter.Value == 0)
{
return(true);
}
if (failureCounter.ForceCheck)
{
return(true);
}
var currentTask = failureCounter.CheckDestination;
if (currentTask.Status != TaskStatus.Running && DelayTimeInMiliSec > 0)
{
var checkDestination = new Task(async delegate
{
for (int i = 0; i < 3; i++)
{
token.ThrowCancellationIfNotDefault();
try
{
var r = await TryOperationAsync <object>(async metadata =>
{
var requestParams = new CreateHttpJsonRequestParams(null, GetServerCheckUrl(metadata.Url), "GET", metadata.Credentials, conventions);
using (var request = requestFactory.CreateHttpJsonRequest(requestParams))
{
await request.ReadResponseJsonAsync().WithCancellation(token).ConfigureAwait(false);
}
return(null);
}, operationMetadata, primaryOperation, true, token).ConfigureAwait(false);
if (r.Success)
{
ResetFailureCount(operationMetadata.Url);
return;
}
}
catch (ObjectDisposedException)
{
return; // disposed, nothing to do here
}
await Task.Delay(DelayTimeInMiliSec, token).ConfigureAwait(false);
}
});
var old = Interlocked.CompareExchange(ref failureCounter.CheckDestination, checkDestination, currentTask);
if (old == currentTask)
{
checkDestination.Start(TaskScheduler.Default);
}
}
return(false);
}
/// <summary>
/// Execute a GET request against the provided url
/// and return the result as a string
/// </summary>
/// <param name="requestUrl">The relative url to the server</param>
/// <remarks>
/// This method respects the replication semantics against the database.
/// </remarks>
public string ExecuteGetRequest(string requestUrl)
{
EnsureIsNotNullOrEmpty(requestUrl, "url");
return(ExecuteWithReplication("GET", serverUrl =>
{
var metadata = new RavenJObject();
AddTransactionInformation(metadata);
var request = jsonRequestFactory.CreateHttpJsonRequest(this, serverUrl + requestUrl, "GET", metadata, credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
return request.ReadResponseString();
}));
}
