public _Guid(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Gets(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Fblocked(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
///////////////////////////////////////////////////////////////////////////////////////////////
public Apply(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Source(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Lappend(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Lindex(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Tell(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Lmap(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Regexp(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Format(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public After(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
///////////////////////////////////////////////////////////////////////////////////////////////
public Fcopy(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public While(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Base64(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Callback(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Split(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
///////////////////////////////////////////////////////////////////////////////////////////////
public Switch(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
private async Task StageRetryByUniqueMessageIds(string requestId, RetryType retryType, string[] messageIds, DateTime startTime, DateTime?last = null, string originator = null, string batchName = null, string classifier = null)
{
if (messageIds == null || !messageIds.Any())
{
log.DebugFormat("Batch '{0}' contains no messages", batchName);
return;
}
var failedMessageRetryIds = messageIds.Select(FailedMessageRetry.MakeDocumentId).ToArray();
var batchDocumentId = await retryDocumentManager.CreateBatchDocument(requestId, retryType, failedMessageRetryIds, originator, startTime, last, batchName, classifier)
.ConfigureAwait(false);
log.InfoFormat("Created Batch '{0}' with {1} messages for '{2}'", batchDocumentId, messageIds.Length, batchName);
var commands = new ICommandData[messageIds.Length];
for (var i = 0; i < messageIds.Length; i++)
{
commands[i] = retryDocumentManager.CreateFailedMessageRetryDocument(batchDocumentId, messageIds[i]);
}
await store.AsyncDatabaseCommands.BatchAsync(commands)
.ConfigureAwait(false);
await retryDocumentManager.MoveBatchToStaging(batchDocumentId).ConfigureAwait(false);
log.InfoFormat("Moved Batch '{0}' to Staging", batchDocumentId);
}
public Downlevel(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Eof(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public void CanUseDefer()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var commands = new ICommandData[]
{
new PutCommandData("company1", null, new DynamicJsonValue {
["Name"] = "company 1"
}),
new PutCommandData("company2", null, new DynamicJsonValue {
["Name"] = "company 2"
})
};
session.Advanced.Defer(commands);
session.Advanced.Defer(new DeleteCommandData("company1", null));
session.SaveChanges();
Assert.Null(session.Load <Company>("company1"));
Assert.NotNull(session.Load <Company>("company2"));
}
}
}
///////////////////////////////////////////////////////////////////////
public Namespace2(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Open(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public _Toplevel(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Proc(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
/// <summary>
/// Begins the async batch operation
/// </summary>
/// <param name="commandDatas">The command data.</param>
/// <returns></returns>
public Task<BatchResult[]> BatchAsync(ICommandData[] commandDatas)
{
var metadata = new JObject();
AddTransactionInformation(metadata);
var req = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/bulk_docs", "POST", metadata, credentials);
var jArray = new JArray(commandDatas.Select(x => x.ToJson()));
var data = Encoding.UTF8.GetBytes(jArray.ToString(Formatting.None));
return Task.Factory.FromAsync(req.BeginWrite, req.EndWrite, data, null)
.ContinueWith(writeTask => Task.Factory.FromAsync<string>(req.BeginReadResponseString, req.EndReadResponseString,null))
.Unwrap()
.ContinueWith(task =>
{
string response;
try
{
response = task.Result;
}
catch (WebException e)
{
var httpWebResponse = e.Response as HttpWebResponse;
if (httpWebResponse == null ||
httpWebResponse.StatusCode != HttpStatusCode.Conflict)
throw;
throw ThrowConcurrencyException(e);
}
return JsonConvert.DeserializeObject<BatchResult[]>(response);
});
}
public Package(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Update(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Upvar(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public Lsort(
ICommandData commandData
)
: base(commandData)
{
// do nothing.
}
public BatchResult[] Batch(ICommandData[] commandDatas)
{
foreach (var commandData in commandDatas)
{
commandData.TransactionInformation = GetTransactionInformation();
}
return database.Batch(commandDatas);
}
protected ActionResult ProcessCommandData(ICommandData commandData,
Func<ActionResult> onSuccess, Func<ActionResult> onFailure = null)
{
CommandDataProcessResult processResult = CommandsDataProcessor.ProcessCommandData(commandData);
if (processResult is CommandDataProcessSuccess)
{
var processSuccess = (CommandDataProcessSuccess)processResult;
LastCommandResult = processSuccess.CommandResult;
return onSuccess();
}
else
{
var processFailure = (CommandDataProcessFailure)processResult;
LastCommandResult = null;
return InvokeFailureAction(processFailure.CommandExceptionModel, onFailure);
}
}
public BatchResult[] Batch(ICommandData[] commandDatas)
{
var metadata = new JObject();
AddTransactionInformation(metadata);
var req = new HttpJsonRequest(url + "/bulk_docs", "POST",metadata);
var jArray = new JArray(commandDatas.Select(x => x.ToJson()));
req.Write(jArray.ToString(Formatting.None));
string response;
try
{
response = req.ReadResponseString();
}
catch (WebException e)
{
var httpWebResponse = e.Response as HttpWebResponse;
if (httpWebResponse == null ||
httpWebResponse.StatusCode != HttpStatusCode.Conflict)
throw;
throw ThrowConcurrencyException(e);
}
return JsonConvert.DeserializeObject<BatchResult[]>(response);
}
private static void Execute(ICommandData self, DocumentDatabase database, BatchResult batchResult)
{
var deleteCommandData = self as DeleteCommandData;
if (deleteCommandData != null)
{
var result = database.Delete(deleteCommandData.Key, deleteCommandData.Etag, deleteCommandData.TransactionInformation);
if (batchResult != null)
batchResult.Deleted = result;
return;
}
var putCommandData = self as PutCommandData;
if (putCommandData != null)
{
var putResult = database.Put(putCommandData.Key, putCommandData.Etag, putCommandData.Document, putCommandData.Metadata, putCommandData.TransactionInformation);
putCommandData.Etag = putResult.ETag;
putCommandData.Key = putResult.Key;
return;
}
var patchCommandData = self as PatchCommandData;
if (patchCommandData != null)
{
var result = database.ApplyPatch(patchCommandData.Key, patchCommandData.Etag,
patchCommandData.Patches, patchCommandData.PatchesIfMissing, patchCommandData.Metadata,
patchCommandData.TransactionInformation);
if (batchResult != null)
batchResult.PatchResult = result.PatchResult;
var doc = database.Get(patchCommandData.Key, patchCommandData.TransactionInformation);
if (doc != null)
{
patchCommandData.Metadata = doc.Metadata;
patchCommandData.Etag = doc.Etag;
}
return;
}
var advPatchCommandData = self as ScriptedPatchCommandData;
if (advPatchCommandData != null)
{
var result = database.ApplyPatch(advPatchCommandData.Key, advPatchCommandData.Etag,
advPatchCommandData.Patch, advPatchCommandData.PatchIfMissing, advPatchCommandData.Metadata,
advPatchCommandData.TransactionInformation, advPatchCommandData.DebugMode);
if (batchResult != null)
batchResult.PatchResult = result.Item1.PatchResult;
advPatchCommandData.AdditionalData = new RavenJObject { { "Debug", new RavenJArray(result.Item2) } };
if(advPatchCommandData.DebugMode)
{
advPatchCommandData.AdditionalData["Document"] = result.Item1.Document;
return;
}
var doc = database.Get(advPatchCommandData.Key, advPatchCommandData.TransactionInformation);
if (doc != null)
{
advPatchCommandData.Metadata = doc.Metadata;
advPatchCommandData.Etag = doc.Etag;
}
return;
}
}
public void Sample()
{
using (var documentStore = this.NewDocumentStore())
{
#region batch_1
var batchResults =
documentStore.DatabaseCommands.Batch(
new ICommandData[]
{
new PutCommandData
{
Document = RavenJObject.FromObject(
new Company
{
Name = "Hibernating Rhinos"
}),
Etag = null,
Key = "rhino1",
Metadata = new RavenJObject(),
},
new PutCommandData
{
Document = RavenJObject.FromObject(
new Company
{
Name = "Hibernating Rhinos"
}),
Etag = null,
Key = "rhino2",
Metadata = new RavenJObject(),
},
new DeleteCommandData
{
Etag = null,
Key = "rhino2"
}
});
#endregion
#region batch_2
using (var session = documentStore.OpenAsyncSession())
{
var commands = new ICommandData[]
{
new PutCommandData
{
Document =
RavenJObject.FromObject(new Company {Name = "Hibernating Rhinos"}),
Etag = null,
Key = "rhino1",
Metadata = new RavenJObject(),
},
new PutCommandData
{
Document =
RavenJObject.FromObject(new Company {Name = "Hibernating Rhinos"}),
Etag = null,
Key = "rhino2",
Metadata = new RavenJObject(),
}
};
session.Advanced.Defer(commands);
session.Advanced.Defer(new DeleteCommandData
{
Etag = null,
Key = "rhino2"
});
}
#endregion
}
}
public async Task Can_defer_commands_until_savechanges_async()
{
using (var session = DocumentStore.OpenAsyncSession())
{
var commands = new ICommandData[]
{
new PutCommandData
{
Document = RavenJObject.FromObject(new Company {Name = "Hibernating Rhinos"}),
Etag = null,
Key = "rhino1",
Metadata = new RavenJObject(),
},
new PutCommandData
{
Document = RavenJObject.FromObject(new Company {Name = "Hibernating Rhinos"}),
Etag = null,
Key = "rhino2",
Metadata = new RavenJObject(),
}
};
session.Advanced.Defer(commands);
session.Advanced.Defer(new DeleteCommandData
{
Etag = null,
Key = "rhino2"
});
Assert.Equal(0, session.Advanced.NumberOfRequests);
await session.SaveChangesAsync();
Assert.Equal(1, session.Advanced.NumberOfRequests); // This returns 0 for some reason in async mode
// Make sure that session is empty
await session.SaveChangesAsync();
Assert.Equal(1, session.Advanced.NumberOfRequests);
}
Assert.Null(DocumentStore.DatabaseCommands.Get("rhino2"));
Assert.NotNull(DocumentStore.DatabaseCommands.Get("rhino1"));
}
/// <summary>
/// Begins the async batch operation
/// </summary>
/// <param name="commandDatas">The command data.</param>
/// <returns></returns>
public Task<BatchResult[]> BatchAsync(ICommandData[] commandDatas)
{
var metadata = new RavenJObject();
AddTransactionInformation(metadata);
var req = jsonRequestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(this, url + "/bulk_docs", "POST", metadata, credentials, convention));
var jArray = new RavenJArray(commandDatas.Select(x => x.ToJson()));
var data = jArray.ToString(Formatting.None);
return Task.Factory.FromAsync(req.BeginWrite, req.EndWrite, data, null)
.ContinueWith(writeTask => req.ReadResponseJsonAsync())
.Unwrap()
.ContinueWith(task =>
{
RavenJArray response;
try
{
response = (RavenJArray)task.Result;
}
catch (AggregateException e)
{
var we = e.ExtractSingleInnerException() as WebException;
if (we == null)
throw;
var httpWebResponse = we.Response as HttpWebResponse;
if (httpWebResponse == null ||
httpWebResponse.StatusCode != HttpStatusCode.Conflict)
throw;
throw ThrowConcurrencyException(we);
}
return convention.CreateSerializer().Deserialize<BatchResult[]>(new RavenJTokenReader(response));
});
}
public IAsyncResult BeginBatch(ICommandData[] commandDatas, AsyncCallback callback, object state)
{
var metadata = new JObject();
AddTransactionInformation(metadata);
var req = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/bulk_docs", "POST", metadata, credentials);
var jArray = new JArray(commandDatas.Select(x => x.ToJson()));
var data = Encoding.UTF8.GetBytes(jArray.ToString(Formatting.None));
var multiStepAsyncResult = new MultiStepAsyncResult(state, req);
var asyncResult = req.BeginWrite(data, ContinueOperation, new Contiuation
{
Callback = callback,
State = state,
Request = req,
MultiAsyncResult = multiStepAsyncResult
});
if (asyncResult.CompletedSynchronously)
{
ContinueOperation(asyncResult);
}
return multiStepAsyncResult;
}
public void CanUseDefer()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var commands = new ICommandData[]
{
new PutCommandData
{
Document =
RavenJObject.FromObject(new Company {Name = "company 1"}),
Etag = null,
Key = "company1",
Metadata = new RavenJObject(),
},
new PutCommandData
{
Document =
RavenJObject.FromObject(new Company {Name = "company 2"}),
Etag = null,
Key = "company2",
Metadata = new RavenJObject(),
}
};
session.Advanced.Defer(commands);
session.Advanced.Defer(new DeleteCommandData { Key = "company1" });
session.SaveChanges();
Assert.Null(session.Load<Company>("company1"));
Assert.NotNull(session.Load<Company>("company2"));
}
}
}
private static bool IsScriptedPatchCommandDataWithoutEtagProperty(ICommandData commandData)
{
var scriptedPatchCommandData = commandData as ScriptedPatchCommandData;
const string ScriptEtagKey = "'@etag':";
const string EtagKey = "etag";
return scriptedPatchCommandData != null && scriptedPatchCommandData.Patch.Script.Replace(" ", string.Empty).Contains(ScriptEtagKey) == false && scriptedPatchCommandData.Patch.Values.ContainsKey(EtagKey) == false;
}
public override void Execute(object parameter)
{
patchModel.ClearQueryError();
AskUser.ConfirmationAsync("Patch Documents", "Are you sure you want to apply this patch to all selected documents?")
.ContinueWhenTrueInTheUIThread(() =>
{
var values = patchModel.GetValues();
if (values == null)
return;
var request = new ScriptedPatchRequest {Script = patchModel.Script.CurrentSnapshot.Text, Values = values};
var selectedItems = patchModel.QueryResults.ItemSelection.GetSelectedItems();
var commands = new ICommandData[selectedItems.Count()];
var counter = 0;
foreach (var item in selectedItems)
{
commands[counter] = new ScriptedPatchCommandData
{
Patch = request,
Key = item.Item.Id
};
counter++;
}
ApplicationModel.Database.Value.AsyncDatabaseCommands
.BatchAsync(commands)
.ContinueOnUIThread(t => { if (t.IsFaulted) patchModel.HandlePatchError(t.Exception); })
.ContinueOnSuccessInTheUIThread(() => ApplicationModel.Database.Value
.AsyncDatabaseCommands
.GetAsync(patchModel.SelectedItem)
.ContinueOnSuccessInTheUIThread(doc =>
{
if (doc != null)
{
patchModel.OriginalDoc.SetText(doc.ToJson().ToString());
patchModel.NewDoc.SetText("");
patchModel.ShowAfterPrompt = true;
}
else
{
patchModel.OriginalDoc.SetText("");
patchModel.NewDoc.SetText("");
patchModel.ShowAfterPrompt = true;
patchModel.ShowBeforeAndAfterPrompt = true;
}
}));
});
}
public Task<BatchResult[]> BatchAsync(ICommandData[] commandDatas)
{
return new CompletedTask<BatchResult[]>(databaseCommands.Batch(commandDatas));
}
public override void Execute(object parameter)
{
patchModel.ClearQueryError();
var values = patchModel.GetValues();
if (values == null)
return;
var request = new ScriptedPatchRequest {Script = patchModel.Script.CurrentSnapshot.Text, Values = values};
var commands = new ICommandData[1];
switch (patchModel.PatchOn)
{
case PatchOnOptions.Document:
ApplicationModel.Database.Value.AsyncDatabaseCommands.GetAsync(patchModel.SelectedItem).
ContinueOnSuccessInTheUIThread(doc => patchModel.OriginalDoc.SetText(doc.ToJson().ToString()));
commands[0] = new ScriptedPatchCommandData
{
Patch = request,
Key = patchModel.SelectedItem,
DebugMode = true
};
break;
case PatchOnOptions.Collection:
case PatchOnOptions.Index:
var selectedItem = patchModel.QueryResults.ItemSelection.GetSelectedItems().FirstOrDefault();
if (selectedItem == null || !selectedItem.IsRealized)
{
return;
}
patchModel.OriginalDoc.SetText(selectedItem.Item.Document.ToJson().ToString());
var docId = selectedItem.Item.Document.Key;
commands[0] = new ScriptedPatchCommandData
{
Patch = request,
Key = docId,
DebugMode = true
};
break;
}
patchModel.InProcess.Value = true;
ApplicationModel.Database.Value.AsyncDatabaseCommands.BatchAsync(commands)
.ContinueOnSuccessInTheUIThread(batch => patchModel.NewDoc.SetText(batch[0].AdditionalData.ToString()))
.ContinueOnUIThread(t => { if (t.IsFaulted) patchModel.HandlePatchError(t.Exception); })
.Finally(() => patchModel.InProcess.Value = false);
patchModel.ShowBeforeAndAfterPrompt = false;
patchModel.ShowAfterPrompt = false;
}
public override void Execute(object parameter)
{
AskUser.ConfirmationAsync("Patch Documents", "Are you sure you want to apply this patch to all matching documents?")
.ContinueWhenTrueInTheUIThread(() =>
{
patchModel.ClearQueryError();
var values = patchModel.GetValues();
if (values == null)
return;
var request = new ScriptedPatchRequest { Script = patchModel.Script.CurrentSnapshot.Text, Values = values};
patchModel.InProcess.Value = true;
switch (patchModel.PatchOn)
{
case PatchOnOptions.Document:
var commands = new ICommandData[1];
commands[0] = new ScriptedPatchCommandData
{
Patch = request,
Key = patchModel.SelectedItem
};
ApplicationModel.Database.Value.AsyncDatabaseCommands.BatchAsync(commands)
.ContinueOnUIThread(t => { if (t.IsFaulted) patchModel.HandlePatchError(t.Exception); })
.ContinueOnSuccessInTheUIThread(
() => ApplicationModel.Database.Value.AsyncDatabaseCommands.GetAsync(patchModel.SelectedItem).
ContinueOnSuccessInTheUIThread(doc =>
{
patchModel.OriginalDoc.SetText(doc.ToJson().ToString());
patchModel.NewDoc.SetText("");
patchModel.ShowAfterPrompt = true;
}))
.Finally(() => patchModel.InProcess.Value = false);
break;
case PatchOnOptions.Collection:
ApplicationModel.Database.Value.AsyncDatabaseCommands.UpdateByIndex(PatchModel.CollectionsIndex,
new IndexQuery { Query = "Tag:" + patchModel.SelectedItem }, request)
.ContinueOnSuccessInTheUIThread(() => patchModel.UpdateCollectionSource())
.ContinueOnUIThread(t => { if (t.IsFaulted) patchModel.HandlePatchError(t.Exception); })
.Finally(() => patchModel.InProcess.Value = false);
break;
case PatchOnOptions.Index:
ApplicationModel.Database.Value.AsyncDatabaseCommands.UpdateByIndex(patchModel.SelectedItem, new IndexQuery { Query = patchModel.QueryDoc.CurrentSnapshot.Text },
request)
.ContinueOnSuccessInTheUIThread(() => patchModel.UpdateCollectionSource())
.ContinueOnUIThread(t => { if (t.IsFaulted) patchModel.HandlePatchError(t.Exception); })
.Finally(() => patchModel.InProcess.Value = false);
break;
}
});
}
private static void Execute(ICommandData self, DocumentDatabase database, BatchResult batchResult, string[] participatingIds = null)
{
var deleteCommandData = self as DeleteCommandData;
if (deleteCommandData != null)
{
var result = database.Documents.Delete(deleteCommandData.Key, deleteCommandData.Etag, deleteCommandData.TransactionInformation,participatingIds);
if (batchResult != null)
batchResult.Deleted = result;
return;
}
var putCommandData = self as PutCommandData;
if (putCommandData != null)
{
var putResult = database.Documents.Put(putCommandData.Key, putCommandData.Etag, putCommandData.Document, putCommandData.Metadata, putCommandData.TransactionInformation, participatingIds);
putCommandData.Etag = putResult.ETag;
putCommandData.Key = putResult.Key;
return;
}
var patchCommandData = self as PatchCommandData;
if (patchCommandData != null)
{
var result = database.Patches.ApplyPatch(patchCommandData.Key, patchCommandData.Etag,
patchCommandData.Patches, patchCommandData.PatchesIfMissing, patchCommandData.Metadata,
patchCommandData.TransactionInformation,
skipPatchIfEtagMismatch: patchCommandData.SkipPatchIfEtagMismatch, participatingIds: participatingIds);
if (batchResult != null)
batchResult.PatchResult = result.PatchResult;
var doc = database.Documents.Get(patchCommandData.Key, patchCommandData.TransactionInformation);
if (doc != null)
{
database.TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() =>
{
patchCommandData.Metadata = doc.Metadata;
patchCommandData.Etag = doc.Etag;
});
}
return;
}
var advPatchCommandData = self as ScriptedPatchCommandData;
if (advPatchCommandData != null)
{
var result = database.Patches.ApplyPatch(advPatchCommandData.Key, advPatchCommandData.Etag,
advPatchCommandData.Patch, advPatchCommandData.PatchIfMissing, advPatchCommandData.Metadata,
advPatchCommandData.TransactionInformation, advPatchCommandData.DebugMode, participatingIds);
if (batchResult != null)
batchResult.PatchResult = result.Item1.PatchResult;
advPatchCommandData.AdditionalData = new RavenJObject { { "Debug", new RavenJArray(result.Item2) } };
if(advPatchCommandData.DebugMode)
{
advPatchCommandData.AdditionalData["Document"] = result.Item1.Document;
advPatchCommandData.AdditionalData["Actions"] = result.Item1.DebugActions;
return;
}
var doc = database.Documents.Get(advPatchCommandData.Key, advPatchCommandData.TransactionInformation);
if (doc != null)
{
database.TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() =>
{
advPatchCommandData.Metadata = doc.Metadata;
advPatchCommandData.Etag = doc.Etag;
});
}
}
}
/// <summary>
/// Begins the async batch operation
/// </summary>
/// <param name="commandDatas">The command data.</param>
/// <returns></returns>
public Task<BatchResult[]> BatchAsync(ICommandData[] commandDatas)
{
var metadata = new JObject();
var req = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/bulk_docs", "POST", metadata, credentials, convention);
var jArray = new JArray(commandDatas.Select(x => x.ToJson()));
var data = Encoding.UTF8.GetBytes(jArray.ToString(Formatting.None));
return req.WriteAsync(data)
.ContinueWith(writeTask => req.ReadResponseStringAsync())
.ContinueWith(task =>
{
string response;
try
{
response = task.Result.Result;
}
catch (WebException e)
{
var httpWebResponse = e.Response as HttpWebResponse;
if (httpWebResponse == null ||
httpWebResponse.StatusCode != HttpStatusCode.Conflict)
throw;
throw ThrowConcurrencyException(e);
}
return JsonConvert.DeserializeObject<BatchResult[]>(response);
});
}
public void Can_defer_commands_until_savechanges()
{
using (var session = documentStore.OpenSession())
{
var commands = new ICommandData[]
{
new PutCommandData
{
Document =
RavenJObject.FromObject(new Company {Name = "Hibernating Rhinos"}),
Etag = null,
Key = "rhino1",
Metadata = new RavenJObject(),
},
new PutCommandData
{
Document =
RavenJObject.FromObject(new Company {Name = "Hibernating Rhinos"}),
Etag = null,
Key = "rhino2",
Metadata = new RavenJObject(),
}
};
session.Advanced.Defer(commands);
session.Advanced.Defer(new DeleteCommandData
{
Etag = null,
Key = "rhino2"
});
session.Store(new Company {Name = "Hibernating Rhinos", Id = "rhino3"});
Assert.Equal(0, session.Advanced.NumberOfRequests);
session.SaveChanges();
Assert.Equal(1, session.Advanced.NumberOfRequests);
// Make sure that session is empty
session.SaveChanges();
Assert.Equal(1, session.Advanced.NumberOfRequests);
}
Assert.Null(documentStore.DatabaseCommands.Get("rhino2"));
Assert.NotNull(documentStore.DatabaseCommands.Get("rhino1"));
Assert.NotNull(documentStore.DatabaseCommands.Get("rhino3"));
}
public DccCommand(ICommandData commandData) : base(commandData)
{
this.Flags |= Utility.GetCommandFlags(GetType().BaseType) |
Utility.GetCommandFlags(this);
}
public void Can_defer_commands_until_savechanges_async()
{
using (var server = GetNewServer(port, path))
{
var documentStore = new DocumentStore { Url = "http://localhost:" + port };
documentStore.Initialize();
using (var session = documentStore.OpenAsyncSession())
{
var commands = new ICommandData[]
{
new PutCommandData
{
Document =
RavenJObject.FromObject(new Company {Name = "Hibernating Rhinos"}),
Etag = null,
Key = "rhino1",
Metadata = new RavenJObject(),
},
new PutCommandData
{
Document =
RavenJObject.FromObject(new Company {Name = "Hibernating Rhinos"}),
Etag = null,
Key = "rhino2",
Metadata = new RavenJObject(),
}
};
session.Advanced.Defer(commands);
session.Advanced.Defer(new DeleteCommandData
{
Etag = null,
Key = "rhino2"
});
Assert.Equal(0, session.Advanced.NumberOfRequests);
session.SaveChangesAsync().Wait();
//Assert.Equal(1, session.Advanced.NumberOfRequests); // This returns 0 for some reason in async mode
// Make sure that session is empty
//session.SaveChangesAsync().Wait();
//Assert.Equal(1, session.Advanced.NumberOfRequests);
}
Assert.Null(documentStore.DatabaseCommands.Get("rhino2"));
Assert.NotNull(documentStore.DatabaseCommands.Get("rhino1"));
}
}
