protected override void ModifyStore(FilesStore store)
{
FactIfWindowsAuthenticationIsAvailable.LoadCredentials();
ConfigurationHelper.ApplySettingsToConventions(store.Conventions);
base.ModifyStore(store);
}
private async Task VerifyDump(FilesStore store, string backupPath, Action <FilesStore> action)
{
try
{
store.DefaultFileSystem += "-Verify";
await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(store.DefaultFileSystem);
bool incremental = false;
var directory = new DirectoryInfo(backupPath);
if (directory.Exists)
{
incremental = true;
}
var dumper = new SmugglerFilesApi {
Options = { Incremental = incremental }
};
await dumper.ImportData(new SmugglerImportOptions <FilesConnectionStringOptions>
{
FromFile = backupPath,
To = new FilesConnectionStringOptions
{
Url = store.Url,
DefaultFileSystem = store.DefaultFileSystem,
}
});
action(store);
}
catch (Exception e)
{
throw e.SimplifyException();
}
}
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 override bool InitBackup()
{
parameters.ServerUrl = parameters.ServerUrl.TrimEnd('/');
try //precaution - to show error properly just in case
{
var serverUri = new Uri(parameters.ServerUrl);
var serverHostname = serverUri.Scheme + Uri.SchemeDelimiter + serverUri.Host + ":" + serverUri.Port;
store = new FilesStore {
Url = serverHostname, DefaultFileSystem = parameters.Filesystem, ApiKey = parameters.ApiKey, Credentials = parameters.Credentials
};
store.Initialize();
}
catch (Exception exc)
{
Console.WriteLine(exc);
try
{
store.Dispose();
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception) { }
return(false);
}
var backupRequest = new
{
BackupLocation = parameters.BackupPath.Replace("\\", "\\\\"),
};
var json = RavenJObject.FromObject(backupRequest).ToString();
var url = "/admin/backup";
if (parameters.Incremental)
{
url += "?incremental=true";
}
try
{
using (var req = CreateRequest("/fs/" + parameters.Filesystem + url, "POST"))
{
req.WriteAsync(json).Wait();
Console.WriteLine("Sending json {0} to {1}", json, parameters.ServerUrl);
var response = req.ReadResponseJson();
Console.WriteLine(response);
}
}
catch (Exception exc)
{
Console.WriteLine(exc);
return(false);
}
return(true);
}
protected virtual FilesStore NewStore(int index = 0, bool fiddler = false, bool enableAuthentication = false, string apiKey = null,
ICredentials credentials = null, string requestedStorage = null, [CallerMemberName] string fileSystemName = null,
bool runInMemory = true, Action <RavenConfiguration> customConfig = null)
{
fileSystemName = NormalizeFileSystemName(fileSystemName);
var server = CreateServer(Ports[index],
fileSystemName: fileSystemName,
enableAuthentication: enableAuthentication,
customConfig: customConfig,
requestedStorage: requestedStorage,
runInMemory: runInMemory);
server.Url = GetServerUrl(fiddler, server.SystemDatabase.ServerUrl);
var store = new FilesStore
{
Url = server.Url,
DefaultFileSystem = fileSystemName,
Credentials = credentials,
ApiKey = apiKey,
};
store.Initialize(true);
this.filesStores.Add(store);
return(store);
}
internal static FilesStore CreateStore(FilesConnectionStringOptions options)
{
var credentials = options.Credentials as NetworkCredential;
if (credentials == null)
{
credentials = CredentialCache.DefaultNetworkCredentials;
}
else if ((string.IsNullOrWhiteSpace(credentials.UserName) || string.IsNullOrWhiteSpace(credentials.Password)))
{
credentials = CredentialCache.DefaultNetworkCredentials;
}
var store = new FilesStore
{
Credentials = credentials,
ApiKey = options.ApiKey,
Url = options.Url,
DefaultFileSystem = options.DefaultFileSystem,
};
store.Initialize(false);
return(store);
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region sorting_1
List <FileHeader> results = await session.Query()
.OrderBy(x => x.Name)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region sorting_2
List <FileHeader> results = await session.Query()
.OrderByDescending("Owner") // order descending by "Owner" metadata
.ToListAsync();
#endregion
}
}
}
protected virtual IAsyncFilesCommands NewAsyncClient(int index = 0, bool fiddler = false, bool enableAuthentication = false, string apiKey = null,
ICredentials credentials = null, string requestedStorage = null, [CallerMemberName] string fileSystemName = null)
{
fileSystemName = NormalizeFileSystemName(fileSystemName);
var server = CreateServer(Ports[index], fileSystemName: fileSystemName, enableAuthentication: enableAuthentication, requestedStorage: requestedStorage);
server.Url = GetServerUrl(fiddler, server.SystemDatabase.ServerUrl);
var store = new FilesStore()
{
Url = server.Url,
DefaultFileSystem = fileSystemName,
Credentials = credentials,
ApiKey = apiKey,
};
store.Initialize(true);
this.filesStores.Add(store);
var client = store.AsyncFilesCommands;
asyncCommandClients.Add(client);
return(client);
}
private static void RunRemoteFilesystemRestoreOperation(string backupLocation, string restoreLocation, string restoreFilesystemName, bool defrag, Uri uri, bool waitForRestore, int?timeout)
{
long operationId;
using (var filesStore = new FilesStore
{
Url = uri.AbsoluteUri
}.Initialize())
{
operationId = filesStore.AsyncFilesCommands.Admin.StartRestore(new FilesystemRestoreRequest
{
BackupLocation = backupLocation,
FilesystemLocation = restoreLocation,
FilesystemName = restoreFilesystemName,
Defrag = defrag,
RestoreStartTimeout = timeout
}).ResultUnwrap();
Console.WriteLine("Started restore operation from {0} on {1} server.", backupLocation, uri.AbsoluteUri);
}
if (waitForRestore)
{
using (var sysDbStore = new DocumentStore
{
Url = uri.AbsoluteUri
}.Initialize())
{
new Operation((AsyncServerClient)sysDbStore.AsyncDatabaseCommands, operationId).WaitForCompletion();
Console.WriteLine("Completed restore operation from {0} on {1} server.", backupLocation, uri.AbsoluteUri);
}
}
}
protected virtual FilesStore NewStore(int index = 0, bool fiddler = false, bool enableAuthentication = false, string apiKey = null,
ICredentials credentials = null, string requestedStorage = null, [CallerMemberName] string fileSystemName = null,
bool runInMemory = true, Action <RavenConfiguration> customConfig = null, string activeBundles = null, string connectionStringName = null)
{
fileSystemName = NormalizeFileSystemName(fileSystemName);
var server = CreateServer(Ports[index],
fileSystemName: fileSystemName,
enableAuthentication: enableAuthentication,
customConfig: customConfig,
requestedStorage: requestedStorage,
runInMemory: runInMemory,
activeBundles: activeBundles);
server.Url = GetServerUrl(fiddler, server.SystemDatabase.ServerUrl);
var store = new FilesStore
{
Url = server.Url,
DefaultFileSystem = fileSystemName,
Credentials = credentials,
ApiKey = apiKey,
ConnectionStringName = connectionStringName
};
store.AfterDispose += (sender, args) => server.Dispose();
ModifyStore(store);
store.Initialize(ensureFileSystemExists: true);
this.filesStores.Add(store);
return(store);
}
internal static async Task <FilesStore> CreateStore(FilesConnectionStringOptions options)
{
var credentials = options.Credentials as NetworkCredential;
if (credentials == null)
{
credentials = CredentialCache.DefaultNetworkCredentials;
}
else if ((String.IsNullOrWhiteSpace(credentials.UserName) || String.IsNullOrWhiteSpace(credentials.Password)))
{
credentials = CredentialCache.DefaultNetworkCredentials;
}
var store = new FilesStore
{
Credentials = credentials,
ApiKey = options.ApiKey,
Url = options.Url,
DefaultFileSystem = options.DefaultFileSystem,
};
store.Initialize();
await ValidateThatServerIsUpAndFilesystemExists(options, store);
return(store);
}
public async Task InitializeAsync(FileSystemSmugglerOptions options, CancellationToken cancellationToken)
{
filesStore = FileStoreHelper.CreateStore(connectionOptions);
await ServerValidation.ValidateThatServerIsUpAndFileSystemExists(connectionOptions, filesStore).ConfigureAwait(false);
await ServerValidation.DetectServerSupportedFeatures(connectionOptions).ConfigureAwait(false); // TODO arek - merge those 2 methods into single one
}
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 CanMigrateAttachmentsToFileSystemOnDifferentServer()
{
using (var store = NewRemoteDocumentStore())
using (GetNewServer(8078))
using (var fsStore = new FilesStore()
{
Url = "http://localhost:8078",
DefaultFileSystem = "RavenDB_2115"
}.Initialize(true))
{
var random = new Random();
var bytes = new byte[137];
random.NextBytes(bytes);
for (int i = 0; i < 10; i++)
{
store.DatabaseCommands.PutAttachment("files/" + i, null, new MemoryStream(bytes), new RavenJObject());
}
new CopyAttachmentsToFileSystem(new RavenConnectionStringOptions()
{
Url = store.Url,
DefaultDatabase = store.DefaultDatabase
}, new RavenConnectionStringOptions()
{
Url = "http://localhost:8078",
}, "RavenDB_2115", false, 1).Execute();
Assert.Equal(10, store.DatabaseCommands.GetStatistics().CountOfAttachments);
var browseResult = await fsStore.AsyncFilesCommands.BrowseAsync();
Assert.Equal(10, browseResult.Length);
for (int i = 10; i < 20; i++)
{
store.DatabaseCommands.PutAttachment("files/" + i, null, new MemoryStream(bytes), new RavenJObject());
}
new CopyAttachmentsToFileSystem(new RavenConnectionStringOptions()
{
Url = store.Url,
DefaultDatabase = store.DefaultDatabase
}, new RavenConnectionStringOptions()
{
Url = "http://localhost:8078",
}, "RavenDB_2115", true, 3).Execute();
Assert.Equal(0, store.DatabaseCommands.GetStatistics().CountOfAttachments);
browseResult = await fsStore.AsyncFilesCommands.BrowseAsync();
Assert.Equal(20, browseResult.Length);
}
}
private static IFilesStore CreateStore()
{
IFilesStore fsStore = new FilesStore()
{
Url = "http://localhost:8080",
DefaultFileSystem = "NorthwindFS"
}.Initialize();
return fsStore;
}
private static IFilesStore CreateFilesStore()
{
IFilesStore store = new FilesStore()
{
Url = "http://localhost:8080",
DefaultFileSystem = "TestFileSystem"
}.Initialize();
return(store);
}
public RavenFsArtefactStorageProvider(RavenFsConfiguration configuration)
{
_filesStore = new FilesStore
{
Url = configuration.Url,
DefaultFileSystem = configuration.FileSystem
};
_filesStore.Initialize();
}
private static IFilesStore CreateStore()
{
IFilesStore fsStore = new FilesStore()
{
Url = "http://localhost:8080",
DefaultFileSystem = "NorthwindFS"
}.Initialize();
return(fsStore);
}
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 static IFilesStore CreateStore(string connectionString)
{
IFilesStore filesStore = new FilesStore()
{
Url = GetConnectionStringElements(connectionString)["Url"],
DefaultFileSystem = GetConnectionStringElements(connectionString)["Database"]
}.Initialize();
ConfigureMaxRequest(filesStore);
return(filesStore);
}
private static IFilesStore CreateStore()
{
var filesStore = new FilesStore()
{
// Url = DocumentStoreHolder.ConnectionStringName,
Url = DemoUtilities.ServerInfo,
DefaultFileSystem = DocumentStoreHolder.NorthwindDatabaseName + "FS"
}.Initialize();
return(filesStore);
}
public CreatingFilesStore()
{
#region create_fs_1
using (IFilesStore fsStore = new FilesStore()
{
Url = "http://localhost:8080",
DefaultFileSystem = "NorthwindFS"
}.Initialize())
{
}
#endregion
}
public CreatingFilesStore()
{
#region create_fs_1
using (IFilesStore fsStore = new FilesStore()
{
Url = "http://localhost:8080",
DefaultFileSystem = "NorthwindFS"
}.Initialize())
{
}
#endregion
}
public void CredentialsAreLoadedFromConnectionString()
{
using (var store = new FilesStore()
{
ConnectionStringName = "RavenFS"
})
{
var credentials = (NetworkCredential)store.Credentials;
Assert.Equal("local_user_test", credentials.UserName);
Assert.Equal("local_user_test", credentials.Password);
Assert.Equal(string.Empty, credentials.Domain);
}
}
public override async Task ImportData(SmugglerImportOptions <FilesConnectionStringOptions> importOptions)
{
if (importOptions.To == null)
{
throw new ArgumentNullException("importOptions");
}
using (primaryStore = await CreateStore(importOptions.To))
using (documentStore = CreateDocumentStore(importOptions.To))
{
Operations = new SmugglerRemoteFilesOperations(() => primaryStore, () => documentStore);
await base.ImportData(importOptions);
}
}
public override async Task <ExportFilesResult> ExportData(SmugglerExportOptions <FilesConnectionStringOptions> exportOptions)
{
if (exportOptions.From == null)
{
throw new ArgumentNullException("exportOptions");
}
using (primaryStore = await CreateStore(exportOptions.From))
using (documentStore = CreateDocumentStore(exportOptions.From))
{
Operations = new SmugglerRemoteFilesOperations(() => primaryStore, () => documentStore);
return(await base.ExportData(exportOptions));
}
}
public async Task CleanerStartupTaskShouldRemoveFileSystemsAfterIdleTimeout()
{
using (var server = GetNewServer())
using (var store = NewRemoteDocumentStore(ravenDbServer: server))
using (var fStore = new FilesStore {
Url = store.Url, DefaultFileSystem = store.DefaultDatabase
}.Initialize())
{
await fStore.AsyncFilesCommands.Admin.CreateFileSystemAsync(MultiDatabase.CreateFileSystemDocument("Northwind"));
await fStore.AsyncFilesCommands.Admin.CreateFileSystemAsync(MultiDatabase.CreateFileSystemDocument("Northwind2"));
await fStore.AsyncFilesCommands.Admin.CreateFileSystemAsync(MultiDatabase.CreateFileSystemDocument("Northwind3"));
await fStore
.AsyncFilesCommands
.ForFileSystem("Northwind2")
.GetStatisticsAsync();
await fStore
.AsyncFilesCommands
.ForFileSystem("Northwind3")
.GetStatisticsAsync();
Assert.NotNull(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind"));
Assert.NotNull(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind2"));
server
.Options
.ServerStartupTasks
.OfType <LiveTestResourceCleanerStartupTask>().First()
.ExecuteCleanup(null);
Assert.Null(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind"));
Assert.NotNull(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind2"));
server.Server.Options.FileSystemLandlord.LastRecentlyUsed["Northwind2"] = DateTime.MinValue;
server
.Options
.ServerStartupTasks
.OfType <LiveTestResourceCleanerStartupTask>().First()
.ExecuteCleanup(null);
Assert.Null(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind2"));
Assert.NotNull(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind3"));
}
}
public MaxRequests()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region max_requests_1
session.Advanced.MaxNumberOfRequestsPerSession = 50;
#endregion
}
#region max_requests_2
store.Conventions.MaxNumberOfRequestsPerSession = 100;
#endregion
}
}
public MaxRequests()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region max_requests_1
session.Advanced.MaxNumberOfRequestsPerSession = 50;
#endregion
}
#region max_requests_2
store.Conventions.MaxNumberOfRequestsPerSession = 100;
#endregion
}
}
protected async Task WaitForSynchronization(FilesStore store)
{
for (int i = 0; i < RetriesCount; i++)
{
using (var session = store.OpenAsyncSession())
{
try
{
var file = await session.DownloadAsync(FileName);
break;
}
catch { }
Thread.Sleep(100);
}
}
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region paging_1
List <FileHeader> results = await session.Query()
.Take(10)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region paging_2
List <FileHeader> results = await session.Query()
.Skip(10)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region paging_3
const int pageSize = 10;
int start = 0;
List <FileHeader> results;
do
{
results = await session.Query()
.Skip(start)
.Take(pageSize)
.ToListAsync();
start += pageSize;
} while (results.Count == pageSize);
#endregion
}
}
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region statistics_1
FilesQueryStatistics stats;
List <FileHeader> results = await session.Query()
.OrderBy(x => x.Name).Statistics(out stats)
.ToListAsync();
#endregion
}
}
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region statistics_1
FilesQueryStatistics stats;
List<FileHeader> results = await session.Query()
.OrderBy(x => x.Name).Statistics(out stats)
.ToListAsync();
#endregion
}
}
}
public RavenDbServer(InMemoryRavenConfiguration configuration)
{
this.configuration = configuration;
documentStore = new DocumentStore
{
Conventions =
{
FailoverBehavior = FailoverBehavior.FailImmediately
}
};
filesStore = new FilesStore
{
Conventions =
{
FailoverBehavior = FailoverBehavior.FailImmediately
}
};
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region paging_1
List<FileHeader> results = await session.Query()
.Take(10)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region paging_2
List<FileHeader> results = await session.Query()
.Skip(10)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region paging_3
const int pageSize = 10;
int start = 0;
List<FileHeader> results;
do
{
results = await session.Query()
.Skip(start)
.Take(pageSize)
.ToListAsync();
start += pageSize;
} while (results.Count == pageSize);
#endregion
}
}
}
public override async Task Between(SmugglerBetweenOptions <FilesConnectionStringOptions> betweenOptions)
{
if (betweenOptions.From == null)
{
throw new ArgumentNullException("betweenOptions.From");
}
if (betweenOptions.To == null)
{
throw new ArgumentNullException("betweenOptions.To");
}
using (primaryStore = await CreateStore(betweenOptions.From))
using (secondaryStore = await CreateStore(betweenOptions.To))
using (documentStore = CreateDocumentStore(betweenOptions.To))
{
Operations = new SmugglerBetweenRemoteFilesOperations(() => primaryStore, () => secondaryStore, () => documentStore);
await base.Between(betweenOptions);
}
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region streaming_2
var allFilesMatchingCriteria = new List<FileHeader>();
var query = session.Query().WhereStartsWith("Name","Fa" );
using (var reader = await session.Advanced.StreamQueryAsync(query))
{
while (await reader.MoveNextAsync())
{
allFilesMatchingCriteria.Add(reader.Current);
}
}
#endregion
}
}
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region sorting_1
List<FileHeader> results = await session.Query()
.OrderBy(x => x.Name)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region sorting_2
List<FileHeader> results = await session.Query()
.OrderByDescending("Owner") // order descending by "Owner" metadata
.ToListAsync();
#endregion
}
}
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
Etag fromEtag = Etag.Empty;
#region streaming_files_2
var allFilesMatchingCriteria = new List<FileHeader>();
using (var reader = await session.Advanced.StreamFileHeadersAsync(fromEtag: fromEtag, pageSize: 10))
{
while (await reader.MoveNextAsync())
{
allFilesMatchingCriteria.Add(reader.Current);
}
}
#endregion
}
}
}
public Encryption()
{
using (var store = new FilesStore())
{
#region encryption_1
store
.AsyncFilesCommands
.Admin
.CreateFileSystemAsync(
new FileSystemDocument
{
Id = "EncryptedFS",
// Other configuration options omitted for simplicity
Settings =
{
// ...
{
"Raven/ActiveBundles", "Encryption"
},
{
"Raven/Encryption/Algorithm",
"System.Security.Cryptography.DESCryptoServiceProvider, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
}
},
SecuredSettings =
{
// ...
{
"Raven/Encryption/Key", "<key_here>"
}
}
});
#endregion
}
}
public async Task Foo()
{
using (var store = new FilesStore())
{
using (var session = store.OpenAsyncSession())
{
#region filtering_1
List<FileHeader> results = await session.Query()
.Where("__fileName:readme* AND Copyright:HR")
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_2
List<FileHeader> results = await session.Query()
.WhereBetween(x => x.TotalSize, 1024 * 1024, 5 * 1024 * 1024) // size has to be > 1KB but < 5KB
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_3
List<FileHeader> results = await session.Query()
.WhereBetweenOrEqual("NumberOfDownloads", 5, 10)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_4
List<FileHeader> results = await session.Query()
.WhereEndsWith(x => x.Name, ".txt")
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_5
List<FileHeader> results = await session.Query()
.WhereEquals("Copyright", "HR")
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
Stream stream = null;
#region filtering_6
session.RegisterUpload("test.file", stream);
session.RegisterUpload("test.fil", stream);
session.RegisterUpload("test.fi", stream);
session.RegisterUpload("test.f", stream);
await session.SaveChangesAsync();
List<FileHeader> results = await session.Query()
.WhereGreaterThan(x => x.Name, "test.fi") // will return 'test.fil' and 'test.file'
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_7
List<FileHeader> results = await session.Query()
.WhereGreaterThanOrEqual("Download-Ratio", 7.3)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_8
List<FileHeader> results = await session.Query()
.WhereIn(x => x.Name, new[] { "readme.txt", "help.doc" })
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_9
List<FileHeader> results = await session.Query()
.WhereLessThan(x => x.TotalSize, 1024)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_10
List<FileHeader> results = await session.Query()
.WhereLessThanOrEqual("Downloaded", 5)
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_11
List<FileHeader> results = await session.Query()
.WhereStartsWith(x => x.FullPath, "/movies/ravenfs")
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
Stream content = null;
#region filtering_12
session.RegisterUpload("git.bin", content, new RavenJObject()
{
{"Attributes", new RavenJArray(new object[]{ "r", "w" }) }
});
session.RegisterUpload("svn.bin", content, new RavenJObject()
{
{"Attributes", new RavenJArray(new object[]{ "w", "x" }) }
});
await session.SaveChangesAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_13
List<FileHeader> results = await session.Query()
.ContainsAll("Attributes", new[] { "r", "w" }) // will return git.bin
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_14
List<FileHeader> results = await session.Query()
.ContainsAny("Attributes", new[] { "r", "x" }) // will return git.bin and svn.bin
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_15
List<FileHeader> results = await session.Query()
.WhereStartsWith(x => x.Name, "readme")
.WhereEquals("Copyright", "HR")
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_16
List<FileHeader> results = await session.Query()
.WhereStartsWith(x => x.Name, "readme")
.AndAlso()
.WhereEquals("Copyright", "HR")
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_17
List<FileHeader> results = await session.Query()
.WhereIn(x => x.Name, new[] { "help.txt", "documentation.doc" })
.OrElse()
.WhereStartsWith(x => x.Name, "readme")
.ToListAsync();
#endregion
}
using (var session = store.OpenAsyncSession())
{
#region filtering_18
List<FileHeader> results = await session.Query()
.OnDirectory("/documents/wallpapers", recursive: true)
.WhereEndsWith(x => x.Name, "1920x1080.jpg")
.ToListAsync();
#endregion
}
}
}
