public CreateHttpJsonRequest ( |
||
createHttpJsonRequestParams | ||
Résultat |
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(); })); }