public async Task<FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
if (sessionOperations.EntityChanged(FileName))
{
if (!sessionOperations.IsDeleted(FileName))
{
var fileHeaderInCache = await session.LoadFileAsync(FileName).ConfigureAwait(false);
Metadata = fileHeaderInCache.Metadata;
}
}
if (Stream != null)
{
await commands.UploadAsync(FileName, Stream, Metadata, Etag)
.ConfigureAwait(false);
}
else if (StreamWriter != null)
{
await commands.UploadAsync(FileName, StreamWriter, null, Size, Metadata, Etag)
.ConfigureAwait(false);
}
else
{
throw new InvalidOperationException("Neither stream not stream writer was specified");
}
var metadata = await commands.GetMetadataForAsync(FileName).ConfigureAwait(false);
if (metadata == null)
return null;
return new FileHeader(FileName, metadata);
}
public async Task <FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
var pipe = new BlockingStream(10);
Task.Run(() => StreamWriter(pipe))
.ContinueWith(x => pipe.CompleteWriting())
.ConfigureAwait(false);
if (sessionOperations.EntityChanged(Filename))
{
if (!sessionOperations.IsDeleted(Filename))
{
var fileHeaderInCache = await session.LoadFileAsync(Filename);
Metadata = fileHeaderInCache.Metadata;
}
}
await commands.UploadAsync(Filename, pipe, Metadata, Size, null)
.ConfigureAwait(false);
var metadata = await commands.GetMetadataForAsync(Filename);
if (metadata == null)
{
return(null);
}
return(new FileHeader(Filename, metadata));
}
public async Task Foo()
{
FilesStore store = null;
#region open_session_2
store.OpenAsyncSession(new OpenFilesSessionOptions()
{
FileSystem = store.DefaultFileSystem
});
#endregion
string filesystem = null;
#region open_session_3
store.OpenAsyncSession(new OpenFilesSessionOptions()
{
FileSystem = filesystem
});
#endregion
#region open_session_4
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
// code here
}
#endregion
}
public async Task<FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
if (sessionOperations.IsDeleted(FileName))
return null;
bool update = true;
foreach ( var listener in sessionOperations.Listeners.MetadataChangeListeners )
{
if (!listener.BeforeChange( FileHeader, Metadata, FileHeader.OriginalMetadata))
{
update = false;
}
}
if (update)
{
await commands.UpdateMetadataAsync(FileName, Metadata, Etag).ConfigureAwait(false);
foreach ( var listener in sessionOperations.Listeners.MetadataChangeListeners )
{
listener.AfterChange(FileHeader, Metadata);
}
}
var metadata = await commands.GetMetadataForAsync(FileName).ConfigureAwait(false);
if (metadata == null)
return null;
return new FileHeader(FileName, metadata);
}
public async Task <FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
await commands.DeleteByQueryAsync(Query).ConfigureAwait(false);
return(null);
}
public async Task<FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
await commands.DeleteByQueryAsync(Query).ConfigureAwait(false);
return null;
}
public async Task<FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
bool delete = true;
FileHeader fileHeader = null;
if (!sessionOperations.TryGetFromCache(Filename, out fileHeader))
fileHeader = await session.LoadFileAsync(Filename);
foreach (var deleteListener in sessionOperations.Listeners.DeleteListeners)
{
if (!deleteListener.BeforeDelete(fileHeader))
delete = false;
}
if (delete)
{
await commands.DeleteAsync(Filename, Etag)
.ConfigureAwait(false);
sessionOperations.RegisterMissing(Filename);
foreach (var deleteListener in sessionOperations.Listeners.DeleteListeners)
{
deleteListener.AfterDelete(Filename);
}
}
return null;
}
public async Task Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
var fileHeader = await session.LoadFileAsync(Path);
bool delete = true;
foreach (var deleteListener in sessionOperations.Listeners.DeleteListeners)
{
if (!deleteListener.BeforeDelete(fileHeader))
{
delete = false;
}
}
if (delete)
{
await commands.DeleteAsync(Path, Etag)
.ConfigureAwait(false);
sessionOperations.RegisterMissing(Path);
foreach (var deleteListener in sessionOperations.Listeners.DeleteListeners)
{
deleteListener.AfterDelete(fileHeader);
}
}
}
public async Task<FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
var pipe = new BlockingStream(10);
var task = Task.Run(() => StreamWriter(pipe))
.ContinueWith(x => { pipe.CompleteWriting(); })
.ConfigureAwait(false);
if (sessionOperations.EntityChanged(Filename))
{
if (!sessionOperations.IsDeleted(Filename))
{
var fileHeaderInCache = await session.LoadFileAsync(Filename);
Metadata = fileHeaderInCache.Metadata;
}
}
await commands.UploadAsync(Filename, pipe, Metadata, Size, null)
.ConfigureAwait(false);
var metadata = await commands.GetMetadataForAsync(Filename);
if (metadata == null)
return null;
return new FileHeader(Filename, metadata);
}
private void GenerateNewSession()
{
session?.Dispose();
session = Store.OpenAsyncSession();
session.Advanced.MaxNumberOfRequestsPerSession = maxRequestsPerSession;
}
public async Task Foo()
{
using (IAsyncFilesSession session = null)
{
#region register_delete_2
session.RegisterFileDeletion("/movies/intro.avi");
session.RegisterFileDeletion(await session.LoadFileAsync("/txt/1.txt"));
await session.SaveChangesAsync();
#endregion
}
using (IAsyncFilesSession session = null)
{
#region register_deletion_query_2
session.RegisterDeletionQuery("__rfileName:tfard.*");
await session.SaveChangesAsync();
#endregion
#region register_deletion_query_3
session.Query()
.WhereEndsWith(x => x.Name, ".draft")
.RegisterResultsForDeletion();
await session.SaveChangesAsync();
#endregion
}
}
public static async Task <string[]> GetRevisionNamesForAsync(this IAsyncFilesSession session, string name, int start, int pageSize)
{
var revisions = await session.Commands.StartsWithAsync(name + "/revisions/", null, start, pageSize).ConfigureAwait(false);
return(revisions
.Select(x => x.FullPath)
.ToArray());
}
public async Task Foo()
{
IAsyncFilesSession session = null;
#region save_changes_2
await session.SaveChangesAsync();
#endregion
}
private Task put_files(IAsyncFilesSession session, string[] files)
{
foreach (var file in files)
{
session.RegisterUpload(file, CreateRandomFileStream(3));
}
return(session.SaveChangesAsync());
}
public async Task Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
await commands.RenameAsync(Source, Destination)
.ConfigureAwait(false);
sessionOperations.RegisterMissing(Source);
}
public async Task Foo()
{
using (var store = new FilesStore())
{
Stream content = new MemoryStream();
Stream newContent = new MemoryStream();
#region optimistic_concurrency_1
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
session.Advanced.UseOptimisticConcurrency = true;
session.RegisterUpload("ravendb.exe", content, new RavenJObject {
{ "Copyright", "hibernatingrhinos.com" }
});
await session.SaveChangesAsync();
using (IAsyncFilesSession otherSession = store.OpenAsyncSession())
{
FileHeader fileInOtherSession = await otherSession.LoadFileAsync("ravendb.exe");
fileInOtherSession.Metadata["Copyright"] = "Hibernating Rhinos LTD";
await otherSession.SaveChangesAsync();
}
FileHeader file = await session.LoadFileAsync("ravendb.exe");
session.RegisterUpload(file, newContent);
await session.SaveChangesAsync(); // will throw ConcurrencyException
}
#endregion
#region optimistic_concurrency_2
store.Conventions.DefaultUseOptimisticConcurrency = true;
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
bool isSessionUsingOptimisticConcurrency = session.Advanced.UseOptimisticConcurrency; // will return true
}
#endregion
#region optimistic_concurrency_3
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
FileHeader file = await session.LoadFileAsync("git.exe");
session.RegisterFileDeletion(file, file.Etag);
await session.SaveChangesAsync();
}
#endregion
}
}
public async Task Foo()
{
IAsyncFilesSession session = null;
#region rename_2
session.RegisterRename("/movies/intro.avi", "/movies/introduction-to-ravenfs.avi");
await session.SaveChangesAsync();
#endregion
}
public async Task Foo()
{
IFilesStore store = null;
#region session_usage_1
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
using (Stream content = File.OpenRead(@"C:\intro.avi"))
{
session.RegisterUpload("/movies/intro.avi", content);
await session.SaveChangesAsync();
}
}
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
FileHeader file = await session.LoadFileAsync("/movies/intro.avi");
using (Stream content = await session.DownloadAsync(file.FullPath))
{
/* ... */
}
if (file.CreationDate < DateTime.Now.AddDays(-1))
{
session.RegisterFileDeletion(file);
}
await session.SaveChangesAsync();
}
#endregion
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
#region unit_of_work_1
Assert.Same(await session.LoadFileAsync("/movies/intro.avi"), await session.LoadFileAsync("/movies/intro.avi"));
#endregion
}
#region unit_of_work_2
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
FileHeader file = await session.LoadFileAsync("/movies/intro.avi");
file.Metadata.Add("Owner", "James");
await session.SaveChangesAsync(); // will sent the metadata update to the file system
}
#endregion
}
public async Task<FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
await commands.RenameAsync(Filename, Destination)
.ConfigureAwait(false);
var metadata = await commands.GetMetadataForAsync(Destination);
if (metadata == null)
return null;
return new FileHeader(Destination, metadata);
}
public static async Task <FileHeader[]> GetRevisionsForAsync(this IAsyncFilesSession session, string name, int start, int pageSize)
{
var inMemoryFilesSessionOperations = (InMemoryFilesSessionOperations)session;
var revisions = await session.Commands.StartsWithAsync(name + "/revisions/", null, start, pageSize).ConfigureAwait(false);
return(revisions
.Select(file =>
{
inMemoryFilesSessionOperations.AddToCache(file.FullPath, file);
return file;
})
.ToArray());
}
public async Task Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
var pipe = new BlockingStream(10);
var task = Task.Run(() => StreamWriter(pipe))
.ContinueWith(x => { pipe.CompleteWriting(); })
.ConfigureAwait(false);
await commands.UploadAsync(Path, pipe, Metadata, Size, null)
.ConfigureAwait(false);
}
public async Task Foo()
{
IFilesStore store = null;
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
#region register_upload_3
using (Stream content = File.OpenRead(@"C:\intro.avi"))
{
session.RegisterUpload("/movies/intro.avi", content);
await session.SaveChangesAsync();
}
#endregion
}
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
#region register_upload_4
session.RegisterUpload("random.bin", 128, stream =>
{
var bytes = new byte[128];
new Random().NextBytes(bytes);
stream.Write(bytes, 0, 128);
});
await session.SaveChangesAsync();
#endregion
}
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
#region register_upload_5
FileHeader ravenFile = await session.LoadFileAsync("/movies/intro.avi");
string localFile = @"C:\intro.avi";
if (ravenFile == null || new FileInfo(localFile).LastWriteTime - ravenFile.LastModified > TimeSpan.FromHours(1))
{
using (Stream content = File.OpenRead(localFile))
{
session.RegisterUpload(ravenFile, content);
await session.SaveChangesAsync();
}
}
#endregion
}
}
public void Dispose()
{
if (session != null)
{
session.Dispose();
session = null;
}
if (store != null)
{
store.Dispose();
store = null;
}
}
public async Task Foo()
{
IAsyncFilesSession session = null;
Stream localFile = null;
#region download_2
Reference <RavenJObject> metadata = new Reference <RavenJObject>();
Stream content = await session.DownloadAsync("/movies/intro.avi", metadata);
Console.WriteLine("Downloaded {0} bytes", metadata.Value.Value <long>("RavenFS-Size"));
#endregion
}
public async Task <FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
await commands.RenameAsync(FileName, Destination, Etag)
.ConfigureAwait(false);
var metadata = await commands.GetMetadataForAsync(Destination);
if (metadata == null)
{
return(null);
}
return(new FileHeader(Destination, metadata));
}
public async Task Foo()
{
IAsyncFilesSession session = null;
#region query_2
List <FileHeader> files = await session.Query().ToListAsync();
#endregion
#region query_3
FileHeader file = await session
.Query()
.WhereLessThan(x => x.TotalSize, 100)
.FirstOrDefaultAsync();
#endregion
}
public async Task Foo()
{
IAsyncFilesSession session = null;
#region load_file_2
FileHeader file = await session.LoadFileAsync("/movies/intro.avi");
#endregion
#region load_file_3
FileHeader[] files = await session.LoadFileAsync(new[]
{
"non-existing-file", "/movies/intro.avi"
}); // will return [null, FileHeader] array
#endregion
}
public async Task <FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
if (sessionOperations.IsDeleted(FileName))
{
return(null);
}
bool update = true;
foreach (var listener in sessionOperations.Listeners.MetadataChangeListeners)
{
if (!listener.BeforeChange(FileHeader, Metadata, FileHeader.OriginalMetadata))
{
update = false;
}
}
if (update)
{
await commands.UpdateMetadataAsync(FileName, Metadata, Etag).ConfigureAwait(false);
foreach (var listener in sessionOperations.Listeners.MetadataChangeListeners)
{
listener.AfterChange(FileHeader, Metadata);
}
}
var metadata = await commands.GetMetadataForAsync(FileName).ConfigureAwait(false);
if (metadata == null)
{
return(null);
}
return(new FileHeader(FileName, metadata));
}
public async Task <FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
if (sessionOperations.EntityChanged(FileName))
{
if (!sessionOperations.IsDeleted(FileName))
{
var fileHeaderInCache = await session.LoadFileAsync(FileName).ConfigureAwait(false);
Metadata = fileHeaderInCache.Metadata;
}
}
if (Stream != null)
{
await commands.UploadAsync(FileName, Stream, Metadata, Etag)
.ConfigureAwait(false);
}
else if (StreamWriter != null)
{
await commands.UploadAsync(FileName, StreamWriter, null, Size, Metadata, Etag)
.ConfigureAwait(false);
}
else
{
throw new InvalidOperationException("Neither stream not stream writer was specified");
}
var metadata = await commands.GetMetadataForAsync(FileName).ConfigureAwait(false);
if (metadata == null)
{
return(null);
}
return(new FileHeader(FileName, metadata));
}
public async Task <FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
bool delete = true;
FileHeader fileHeader = null;
if (!sessionOperations.TryGetFromCache(FileName, out fileHeader))
{
fileHeader = await session.LoadFileAsync(FileName).ConfigureAwait(false);
}
foreach (var deleteListener in sessionOperations.Listeners.DeleteListeners)
{
if (!deleteListener.BeforeDelete(fileHeader))
{
delete = false;
}
}
if (delete)
{
await commands.DeleteAsync(FileName, Etag)
.ConfigureAwait(false);
sessionOperations.RegisterMissing(FileName);
foreach (var deleteListener in sessionOperations.Listeners.DeleteListeners)
{
deleteListener.AfterDelete(FileName);
}
}
return(null);
}
public RavenResultsFileRepository(IAsyncFilesSession session)
{
_session = session;
}
private Task put_files(IAsyncFilesSession session, string[] files)
{
foreach (var file in files)
{
session.RegisterUpload(file, CreateRandomFileStream(3));
}
return session.SaveChangesAsync();
}
