public async Task ShouldThrowWhenWindowsDocumentDoesNotContainFileSystem()
{
// in this test be careful if the specified credentials belong to admin user or not
// to make this test pass you need to specify the credentials of a user who isn't an admin on this machine
var client = NewAsyncClient(enableAuthentication: true, credentials: new NetworkCredential(FactIfWindowsAuthenticationIsAvailable.User.UserName, FactIfWindowsAuthenticationIsAvailable.User.Password, FactIfWindowsAuthenticationIsAvailable.User.Domain));
var server = GetServer();
await client.UploadAsync("abc.bin", new MemoryStream(1));
using (var anotherClient = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "ShouldThrow_WindowsDocumentDoesNotContainsThisFS",
conventions: client.Conventions,
credentials: new OperationCredentials(null, new NetworkCredential(FactIfWindowsAuthenticationIsAvailable.User.UserName, FactIfWindowsAuthenticationIsAvailable.User.Password, FactIfWindowsAuthenticationIsAvailable.User.Domain))))
{
await anotherClient.EnsureFileSystemExistsAsync(); // will pass because by using this api key we have access to <system> database
ErrorResponseException errorResponse = null;
try
{
await anotherClient.UploadAsync("def.bin", new MemoryStream(1)); // should throw because a file system ShouldThrow_WindowsDocumentDoesNotContainsThisFS isn't added to ApiKeyDefinition
}
catch (ErrorResponseException ex)
{
errorResponse = ex;
}
Assert.NotNull(errorResponse);
Assert.Equal(HttpStatusCode.Forbidden, errorResponse.StatusCode);
}
}
public async Task WillUseDefaultNetworkCredentialsWhenServerRequiresAuthentication()
{
var server = CreateRavenDbServer(Ports[0], fileSystemName: "WillUseDefaultCredentials", enableAuthentication: true); // enable authentication
using (var client = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "WillUseDefaultCredentials"))
{
await client.Admin.CreateFileSystemAsync(new FileSystemDocument()
{
Id = "Raven/FileSystem/" + client.FileSystem,
Settings =
{
{"Raven/FileSystem/DataDir", Path.Combine("FileSystems", client.FileSystem)}
}
});
await client.UploadAsync("a", new MemoryStream(new byte[] { 1, 2 }));
var ms = new MemoryStream();
(await client.DownloadAsync("a")).CopyTo(ms);
var array = ms.ToArray();
Assert.Equal(1, array[0]);
Assert.Equal(2, array[1]);
}
}
public async Task ShouldThrowWhenWindowsDocumentDoesNotContainFileSystem()
{
// in this test be careful if the specified credentials belong to admin user or not
var client = NewAsyncClient(enableAuthentication: true, credentials: new NetworkCredential(username, password, domain));
var server = GetServer();
await client.UploadAsync("abc.bin", new RandomStream(3));
using (var anotherClient = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "ShouldThrow_WindowsDocumentDoesnContainsThisFS",
credentials: new NetworkCredential(username, password, domain)))
{
await anotherClient.EnsureFileSystemExistsAsync(); // will pass because by using this api key we have access to <system> database
ErrorResponseException errorResponse = null;
try
{
await anotherClient.UploadAsync("def.bin", new RandomStream(1)); // should throw because a file system ShouldThrow_ApiKeyDoesnContainsThisFS isn't added to ApiKeyDefinition
}
catch (InvalidOperationException ex)
{
errorResponse = ex.InnerException as ErrorResponseException;
}
Assert.NotNull(errorResponse);
Assert.Equal(HttpStatusCode.Forbidden, errorResponse.StatusCode);
}
}
public IAsyncFilesSession OpenAsyncSession(OpenFilesSessionOptions sessionOptions)
{
AssertInitialized();
EnsureNotClosed();
if (string.IsNullOrWhiteSpace(sessionOptions.FileSystem))
{
throw new ArgumentException("Filesystem cannot be null, empty or whitespace.", "FileSystem");
}
var sessionId = Guid.NewGuid();
currentSessionId = sessionId;
try
{
var client = new AsyncFilesServerClient(this.Url, sessionOptions.FileSystem, sessionOptions.Credentials, sessionOptions.ApiKey);
var session = new AsyncFilesSession(this, client, this.Listeners, sessionId);
AfterSessionCreated(session);
return(session);
}
finally
{
currentSessionId = null;
}
}
public async Task CanCreateAndDeleteFileSystem()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient();
var adminClient = client.Admin;
const string newFileSystemName = "testName_CanDeleteFileSystem";
await adminClient.CreateOrUpdateFileSystemAsync(new FileSystemDocument
{
Id = "Raven/FileSystem/" + newFileSystemName,
Settings =
{
{ Constants.FileSystem.DataDirectory, Path.Combine("~", Path.Combine("FileSystems", newFileSystemName)) }
}
}, newFileSystemName);
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, newFileSystemName))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] { 1 }));
}
var names = await adminClient.GetNamesAsync();
Assert.Contains(newFileSystemName, names);
var stats = await adminClient.GetStatisticsAsync();
Assert.NotNull(stats.FirstOrDefault(x => x.Name == newFileSystemName));
await adminClient.DeleteFileSystemAsync(newFileSystemName);
names = await adminClient.GetNamesAsync();
Assert.DoesNotContain(newFileSystemName, names);
}
public async Task WillUseDefaultNetworkCredentialsWhenServerRequiresAuthentication_CommandsUsage()
{
var server = CreateServer(8079, fileSystemName: "WillUseDefaultCredentials", enableAuthentication: true); // enable authentication
using (var client = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "WillUseDefaultCredentials"))
{
await client.Admin.CreateFileSystemAsync(new FileSystemDocument()
{
Id = "Raven/FileSystem/" + client.FileSystemName,
Settings =
{
{ Constants.FileSystem.DataDirectory, Path.Combine("FileSystems", client.FileSystemName) }
}
});
await client.UploadAsync("a", new MemoryStream(new byte[] { 1, 2 }));
await client.UploadAsync("b", new MemoryStream(new byte[] { 2, 1, 0 }));
var ms = new MemoryStream();
(await client.DownloadAsync("a")).CopyTo(ms);
var array = ms.ToArray();
Assert.Equal(1, array[0]);
Assert.Equal(2, array[1]);
ms = new MemoryStream();
(await client.DownloadAsync("b")).CopyTo(ms);
array = ms.ToArray();
Assert.Equal(2, array[0]);
Assert.Equal(1, array[1]);
Assert.Equal(0, array[2]);
}
}
public async Task Can_get_stats_for_all_active_file_systems()
{
var client = NewAsyncClient();
var server = GetServer();
using (var anotherClient = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "test"))
{
await anotherClient.EnsureFileSystemExistsAsync();
await client.UploadAsync("test1", new RandomStream(10)); // will make it active
await anotherClient.UploadAsync("test1", new RandomStream(10)); // will make it active
await client.UploadAsync("test2", new RandomStream(10));
var stats = await anotherClient.Admin.GetStatisticsAsync();
var stats1 = stats.FirstOrDefault(x => x.Name == client.FileSystemName);
Assert.NotNull(stats1);
var stats2 = stats.FirstOrDefault(x => x.Name == anotherClient.FileSystemName);
Assert.NotNull(stats2);
Assert.Equal(2, stats1.Metrics.Requests.Count);
Assert.Equal(1, stats2.Metrics.Requests.Count);
Assert.Equal(0, stats1.ActiveSyncs.Count);
Assert.Equal(0, stats1.PendingSyncs.Count);
Assert.Equal(0, stats2.ActiveSyncs.Count);
Assert.Equal(0, stats2.PendingSyncs.Count);
}
}
public async Task ShouldThrowWhenUsedApiKeyDefinitionDoesNotContainFileSystem()
{
var client = NewAsyncClient(enableAuthentication: true, apiKey: apiKey);
var server = GetServer();
await client.UploadAsync("abc.bin", new RandomStream(3));
using (var anotherClient = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "ShouldThrow_ApiKeyDoesnContainsThisFS", apiKey: apiKey))
{
await anotherClient.EnsureFileSystemExistsAsync(); // will pass because by using this api key we have access to <system> database
ErrorResponseException errorResponse = null;
try
{
await anotherClient.UploadAsync("def.bin", new RandomStream(1)); // should throw because a file system ShouldThrow_ApiKeyDoesnContainsThisFS isn't added to ApiKeyDefinition
}
catch (ErrorResponseException ex)
{
errorResponse = ex;
}
Assert.NotNull(errorResponse);
Assert.Equal(HttpStatusCode.Forbidden, errorResponse.StatusCode);
}
}
public async Task AdminClientWorkWithOAuthEnabled()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient(enableAuthentication: true, apiKey: apiKey);
var adminClient = client.Admin;
await adminClient.CreateFileSystemAsync(new FileSystemDocument
{
Id = "Raven/FileSystem/" + "testName",
Settings =
{
{ Constants.FileSystem.DataDirectory, Path.Combine("~", Path.Combine("FileSystems", "testName")) }
}
}, "testName");
var names = await adminClient.GetNamesAsync();
Assert.Equal(2, names.Length);
Assert.Contains("AdminClientWorkWithOAuthEnabled", names);
var stats = await adminClient.GetStatisticsAsync();
Assert.Equal(0, stats.Length); // 0 because our fs aren't active
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, "testName"))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] { 1 }));
}
await adminClient.DeleteFileSystemAsync("testName", true);
}
public async Task AdminClientWorkWithWinAuthEnabled()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient(enableAuthentication: true, credentials: new NetworkCredential(FactIfWindowsAuthenticationIsAvailable.Admin.UserName, FactIfWindowsAuthenticationIsAvailable.Admin.Password, FactIfWindowsAuthenticationIsAvailable.Admin.Domain));
var adminClient = client.Admin;
await adminClient.CreateFileSystemAsync(MultiDatabase.CreateFileSystemDocument("testName"), "testName");
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, "testName", new NetworkCredential(FactIfWindowsAuthenticationIsAvailable.Admin.UserName, FactIfWindowsAuthenticationIsAvailable.Admin.Password, FactIfWindowsAuthenticationIsAvailable.Admin.Domain)))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] { 1 }));
}
var names = await adminClient.GetNamesAsync();
Assert.Contains("testName", names);
var stats = await adminClient.GetStatisticsAsync();
Assert.NotNull(stats.FirstOrDefault(x => x.Name == "testName"));
await adminClient.DeleteFileSystemAsync("testName");
names = await adminClient.GetNamesAsync();
Assert.DoesNotContain("testName", names);
}
public async Task ShouldThrowWhenWindowsDocumentDoesNotContainFileSystem()
{
// in this test be careful if the specified credentials belong to admin user or not
// to make this test pass you need to specify the credentials of a user who isn't an admin on this machine
var client = NewAsyncClient(enableAuthentication: true, credentials: new NetworkCredential(FactIfWindowsAuthenticationIsAvailable.User.UserName, FactIfWindowsAuthenticationIsAvailable.User.Password, FactIfWindowsAuthenticationIsAvailable.User.Domain));
var server = GetServer();
await client.UploadAsync("abc.bin", new MemoryStream(1));
using (var anotherClient = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "ShouldThrow_WindowsDocumentDoesNotContainsThisFS",
conventions: client.Conventions,
credentials: new OperationCredentials(null, new NetworkCredential(FactIfWindowsAuthenticationIsAvailable.User.UserName, FactIfWindowsAuthenticationIsAvailable.User.Password, FactIfWindowsAuthenticationIsAvailable.User.Domain))))
{
await anotherClient.EnsureFileSystemExistsAsync(); // will pass because by using this api key we have access to <system> database
ErrorResponseException errorResponse = null;
try
{
await anotherClient.UploadAsync("def.bin", new MemoryStream(1)); // should throw because a file system ShouldThrow_WindowsDocumentDoesNotContainsThisFS isn't added to ApiKeyDefinition
}
catch (ErrorResponseException ex)
{
errorResponse = ex;
}
Assert.NotNull(errorResponse);
Assert.Equal(HttpStatusCode.Forbidden, errorResponse.StatusCode);
}
}
public async Task AdminClientWorkWithWinAuthEnabled()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient(enableAuthentication: true, credentials: new NetworkCredential(username, password, domain));
var adminClient = client.Admin;
await adminClient.CreateFileSystemAsync(new FileSystemDocument
{
Id = "Raven/FileSystem/" + "testName",
Settings =
{
{ "Raven/FileSystem/DataDir", Path.Combine("~", Path.Combine("FileSystems", "testName")) }
}
}, "testName");
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, "testName", new NetworkCredential(username, password, domain)))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] { 1 }));
}
var names = await adminClient.GetNamesAsync();
Assert.Contains("testName", names);
var stats = await adminClient.GetStatisticsAsync();
Assert.NotNull(stats.FirstOrDefault(x => x.Name == "testName"));
await adminClient.DeleteFileSystemAsync("testName");
names = await adminClient.GetNamesAsync();
Assert.DoesNotContain("testName", names);
}
protected AsyncFilesServerClient CreateFileSystemClient(RavenConnectionStringOptions options, string fileSystemName)
{
var fsClient = new AsyncFilesServerClient(options.Url, fileSystemName, apiKey: options.ApiKey, credentials: options.Credentials);
ValidateThatServerIsUpAndFileSystemExists(fsClient);
return fsClient;
}
protected AsyncFilesServerClient CreateFileSystemClient(RavenConnectionStringOptions options, string fileSystemName)
{
var fsClient = new AsyncFilesServerClient(options.Url, fileSystemName, apiKey: options.ApiKey, credentials: options.Credentials);
ValidateThatServerIsUpAndFileSystemExists(fsClient);
return(fsClient);
}
public async Task <SynchronizationReport> SynchronizeFileToAsync(string fileName, SynchronizationDestination destination)
{
ICredentials credentials = null;
if (string.IsNullOrEmpty(destination.Username) == false)
{
credentials = string.IsNullOrEmpty(destination.Domain)
? new NetworkCredential(destination.Username, destination.Password)
: new NetworkCredential(destination.Username, destination.Password, destination.Domain);
}
var destinationClient = new AsyncFilesServerClient(destination.ServerUrl, destination.FileSystem, apiKey: destination.ApiKey, credentials: credentials).Synchronization;
RavenJObject destinationMetadata;
try
{
destinationMetadata = await destinationClient.Commands.GetMetadataForAsync(fileName);
}
catch (Exception ex)
{
var exceptionMessage = "Could not get metadata details for " + fileName + " from " + destination.Url;
Log.WarnException(exceptionMessage, ex);
return(new SynchronizationReport(fileName, Guid.Empty, SynchronizationType.Unknown)
{
Exception = new SynchronizationException(exceptionMessage, ex)
});
}
RavenJObject localMetadata = GetLocalMetadata(fileName);
NoSyncReason reason;
SynchronizationWorkItem work = synchronizationStrategy.DetermineWork(fileName, localMetadata, destinationMetadata, FileSystemUrl, out reason);
if (work == null)
{
Log.Debug("File '{0}' was not synchronized to {1}. {2}", fileName, destination.Url, reason.GetDescription());
return(new SynchronizationReport(fileName, Guid.Empty, SynchronizationType.Unknown)
{
Exception = new SynchronizationException(reason.GetDescription())
});
}
return(await PerformSynchronizationAsync(destinationClient, work));
}
protected void ValidateThatServerIsUpAndFileSystemExists(AsyncFilesServerClient fsClient)
{
var shouldDispose = false;
try
{
var fileSystemStats = fsClient.GetStatisticsAsync().Result;
}
catch (Exception e)
{
shouldDispose = true;
var responseException = e as ErrorResponseException;
if (responseException != null && responseException.StatusCode == HttpStatusCode.ServiceUnavailable && responseException.Message.StartsWith("Could not find a file system named:"))
{
throw new InvalidOperationException(
string.Format(
"Migration tool does not support file system creation (file system '{0}' on server '{1}' must exist before running this tool).",
fsClient.FileSystem,
fsClient.ServerUrl), e);
}
if (e.InnerException != null)
{
var webException = e.InnerException as WebException;
if (webException != null)
{
throw new InvalidOperationException(string.Format("Migration tool encountered a connection problem: '{0}'.", webException.Message), webException);
}
}
throw new InvalidOperationException(string.Format("Migration tool encountered a connection problem: '{0}'.", e.Message), e);
}
finally
{
if (shouldDispose)
{
fsClient.Dispose();
}
}
}
public async Task CanCreateFileSystemWithDefaultValues()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient();
var adminClient = client.Admin;
const string newFileSystemName = "testName_CanCreateFileSystemWithDefaultValues";
await adminClient.CreateOrUpdateFileSystemAsync(new FileSystemDocument(), newFileSystemName);
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, newFileSystemName))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] { 1 }));
}
var names = await adminClient.GetNamesAsync();
Assert.Contains(newFileSystemName, names);
var stats = await adminClient.GetStatisticsAsync();
Assert.NotNull(stats.FirstOrDefault(x => x.Name == newFileSystemName));
}
public async Task AdminClientWorkWithOAuthEnabled()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient(enableAuthentication: true, apiKey: apiKey);
var adminClient = client.Admin;
await adminClient.CreateFileSystemAsync(MultiDatabase.CreateFileSystemDocument("testName"));
var names = await adminClient.GetNamesAsync();
Assert.Equal(2, names.Length);
Assert.Contains("AdminClientWorkWithOAuthEnabled", names);
var stats = await adminClient.GetStatisticsAsync();
Assert.Equal(0, stats.Length); // 0 because our fs aren't active
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, "testName"))
{
var buffer = Enumerable.Range(1, 1).Select(x => (byte)(x % byte.MaxValue)).ToArray();
await createdFsClient.UploadAsync("fooFoo", new MemoryStream(buffer));
}
await adminClient.DeleteFileSystemAsync("testName", true);
}
protected void ValidateThatServerIsUpAndFileSystemExists(AsyncFilesServerClient fsClient)
{
var shouldDispose = false;
try
{
var fileSystemStats = fsClient.GetStatisticsAsync().Result;
}
catch (Exception e)
{
shouldDispose = true;
var responseException = e as ErrorResponseException;
if (responseException != null && responseException.StatusCode == HttpStatusCode.ServiceUnavailable && responseException.Message.StartsWith("Could not find a file system named:"))
throw new InvalidOperationException(
string.Format(
"Migration tool does not support file system creation (file system '{0}' on server '{1}' must exist before running this tool).",
fsClient.FileSystemName,
fsClient.ServerUrl), e);
if (e.InnerException != null)
{
var webException = e.InnerException as WebException;
if (webException != null)
{
throw new InvalidOperationException(string.Format("Migration tool encountered a connection problem: '{0}'.", webException.Message), webException);
}
}
throw new InvalidOperationException(string.Format("Migration tool encountered a connection problem: '{0}'.", e.Message), e);
}
finally
{
if (shouldDispose)
fsClient.Dispose();
}
}
public async Task<SynchronizationReport> SynchronizeFileToAsync(string fileName, SynchronizationDestination destination)
{
ICredentials credentials = null;
if (string.IsNullOrEmpty(destination.Username) == false)
{
credentials = string.IsNullOrEmpty(destination.Domain)
? new NetworkCredential(destination.Username, destination.Password)
: new NetworkCredential(destination.Username, destination.Password, destination.Domain);
}
var destinationClient = new AsyncFilesServerClient(destination.ServerUrl, destination.FileSystem, apiKey: destination.ApiKey, credentials: credentials).Synchronization;
RavenJObject destinationMetadata;
try
{
destinationMetadata = await destinationClient.Commands.GetMetadataForAsync(fileName);
}
catch (Exception ex)
{
var exceptionMessage = "Could not get metadata details for " + fileName + " from " + destination.Url;
Log.WarnException(exceptionMessage, ex);
return new SynchronizationReport(fileName, Guid.Empty, SynchronizationType.Unknown)
{
Exception = new SynchronizationException(exceptionMessage, ex)
};
}
RavenJObject localMetadata = GetLocalMetadata(fileName);
NoSyncReason reason;
SynchronizationWorkItem work = synchronizationStrategy.DetermineWork(fileName, localMetadata, destinationMetadata, FileSystemUrl, out reason);
if (work == null)
{
Log.Debug("File '{0}' was not synchronized to {1}. {2}", fileName, destination.Url, reason.GetDescription());
return new SynchronizationReport(fileName, Guid.Empty, SynchronizationType.Unknown)
{
Exception = new SynchronizationException(reason.GetDescription())
};
}
return await PerformSynchronizationAsync(destinationClient, work);
}
public async Task ShouldThrowWhenWindowsDocumentDoesNotContainFileSystem()
{
// in this test be careful if the specified credentials belong to admin user or not
var client = NewAsyncClient(enableAuthentication: true, credentials: new NetworkCredential(username, password, domain));
var server = GetServer();
await client.UploadAsync("abc.bin", new RandomStream(3));
using (var anotherClient = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "ShouldThrow_WindowsDocumentDoesnContainsThisFS",
credentials: new NetworkCredential(username, password, domain)))
{
await anotherClient.EnsureFileSystemExistsAsync(); // will pass because by using this api key we have access to <system> database
ErrorResponseException errorResponse = null;
try
{
await anotherClient.UploadAsync("def.bin", new RandomStream(1)); // should throw because a file system ShouldThrow_ApiKeyDoesnContainsThisFS isn't added to ApiKeyDefinition
}
catch (InvalidOperationException ex)
{
errorResponse = ex.InnerException as ErrorResponseException;
}
Assert.NotNull(errorResponse);
Assert.Equal(HttpStatusCode.Forbidden, errorResponse.StatusCode);
}
}
public async Task AdminClientWorkWithWinAuthEnabled()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient(enableAuthentication: true, credentials: new NetworkCredential(username, password, domain));
var adminClient = client.Admin;
await adminClient.CreateFileSystemAsync(new FileSystemDocument
{
Id = "Raven/FileSystem/" + "testName",
Settings =
{
{"Raven/FileSystem/DataDir", Path.Combine("~", Path.Combine("FileSystems", "testName"))}
}
}, "testName");
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, "testName", new NetworkCredential(username, password, domain)))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] {1}));
}
var names = await adminClient.GetNamesAsync();
Assert.Contains("testName", names);
var stats = await adminClient.GetStatisticsAsync();
Assert.NotNull(stats.FirstOrDefault(x => x.Name == "testName"));
await adminClient.DeleteFileSystemAsync("testName");
names = await adminClient.GetNamesAsync();
Assert.DoesNotContain("testName", names);
}
public async Task CanCreateAndDeleteFileSystem()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient();
var adminClient = client.Admin;
const string newFileSystemName = "testName_CanDeleteFileSystem";
await adminClient.CreateOrUpdateFileSystemAsync(new FileSystemDocument
{
Id = "Raven/FileSystem/" + newFileSystemName,
Settings =
{
{Constants.FileSystem.DataDirectory, Path.Combine("~", Path.Combine("FileSystems", newFileSystemName))}
}
}, newFileSystemName);
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, newFileSystemName))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] { 1 }));
}
var names = await adminClient.GetNamesAsync();
Assert.Contains(newFileSystemName, names);
var stats = await adminClient.GetStatisticsAsync();
Assert.NotNull(stats.FirstOrDefault(x => x.Name == newFileSystemName));
await adminClient.DeleteFileSystemAsync(newFileSystemName);
names = await adminClient.GetNamesAsync();
Assert.DoesNotContain(newFileSystemName, names);
}
public async Task CanCreateFileSystemWithDefaultValues()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient();
var adminClient = client.Admin;
const string newFileSystemName = "testName_CanCreateFileSystemWithDefaultValues";
await adminClient.CreateOrUpdateFileSystemAsync(new FileSystemDocument(), newFileSystemName);
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, newFileSystemName))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] { 1 }));
}
var names = await adminClient.GetNamesAsync();
Assert.Contains(newFileSystemName, names);
var stats = await adminClient.GetStatisticsAsync();
Assert.NotNull(stats.FirstOrDefault(x => x.Name == newFileSystemName));
}
public async Task Can_get_stats_for_all_active_file_systems()
{
var client = NewAsyncClient();
var server = GetServer();
using (var anotherClient = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "test"))
{
await anotherClient.EnsureFileSystemExistsAsync();
await client.UploadAsync("test1", new RandomStream(10)); // will make it active
await anotherClient.UploadAsync("test1", new RandomStream(10)); // will make it active
await client.UploadAsync("test2", new RandomStream(10));
var stats = await anotherClient.Admin.GetStatisticsAsync();
var stats1 = stats.FirstOrDefault(x => x.Name == client.FileSystemName);
Assert.NotNull(stats1);
var stats2 = stats.FirstOrDefault(x => x.Name == anotherClient.FileSystemName);
Assert.NotNull(stats2);
Assert.Equal(2, stats1.Metrics.Requests.Count);
Assert.Equal(1, stats2.Metrics.Requests.Count);
Assert.Equal(0, stats1.ActiveSyncs.Count);
Assert.Equal(0, stats1.PendingSyncs.Count);
Assert.Equal(0, stats2.ActiveSyncs.Count);
Assert.Equal(0, stats2.PendingSyncs.Count);
}
}
private async Task <DestinationSyncResult> SynchronizeDestinationAsync(SynchronizationDestination destination,
bool forceSyncingContinuation)
{
try
{
ICredentials credentials = null;
if (string.IsNullOrEmpty(destination.Username) == false)
{
credentials = string.IsNullOrEmpty(destination.Domain)
? new NetworkCredential(destination.Username, destination.Password)
: new NetworkCredential(destination.Username, destination.Password, destination.Domain);
}
var destinationClient = new AsyncFilesServerClient(destination.ServerUrl, destination.FileSystem,
apiKey: destination.ApiKey, credentials: credentials).Synchronization;
var lastETag = await destinationClient.GetLastSynchronizationFromAsync(storage.Id);
var activeTasks = synchronizationQueue.Active;
var filesNeedConfirmation = GetSyncingConfigurations(destination).Where(sync => activeTasks.All(x => x.FileName != sync.FileName)).ToList();
var confirmations = await ConfirmPushedFiles(filesNeedConfirmation, destinationClient);
var needSyncingAgain = new List <FileHeader>();
foreach (var confirmation in confirmations)
{
if (confirmation.Status == FileStatus.Safe)
{
Log.Debug("Destination server {0} said that file '{1}' is safe", destination, confirmation.FileName);
RemoveSyncingConfiguration(confirmation.FileName, destination.Url);
}
else
{
storage.Batch(accessor =>
{
var fileHeader = accessor.ReadFile(confirmation.FileName);
if (fileHeader != null)
{
needSyncingAgain.Add(fileHeader);
Log.Debug("Destination server {0} said that file '{1}' is {2}.", destination, confirmation.FileName, confirmation.Status);
}
});
}
}
await EnqueueMissingUpdatesAsync(destinationClient, lastETag, needSyncingAgain);
var reports = await Task.WhenAll(SynchronizePendingFilesAsync(destinationClient, forceSyncingContinuation));
var destinationSyncResult = new DestinationSyncResult
{
DestinationServer = destination.ServerUrl,
DestinationFileSystem = destination.FileSystem
};
if (reports.Length > 0)
{
var successfulSynchronizationsCount = reports.Count(x => x.Exception == null);
var failedSynchronizationsCount = reports.Count(x => x.Exception != null);
if (successfulSynchronizationsCount > 0 || failedSynchronizationsCount > 0)
{
Log.Debug(
"Synchronization to a destination {0} has completed. {1} file(s) were synchronized successfully, {2} synchronization(s) were failed",
destination.Url, successfulSynchronizationsCount, failedSynchronizationsCount);
}
destinationSyncResult.Reports = reports;
}
return(destinationSyncResult);
}
catch (Exception ex)
{
Log.WarnException(string.Format("Failed to perform a synchronization to a destination {0}", destination), ex);
return(new DestinationSyncResult
{
DestinationServer = destination.ServerUrl,
DestinationFileSystem = destination.FileSystem,
Exception = ex
});
}
}
private async Task<DestinationSyncResult> SynchronizeDestinationAsync(SynchronizationDestination destination,
bool forceSyncingContinuation)
{
try
{
ICredentials credentials = null;
if (string.IsNullOrEmpty(destination.Username) == false)
{
credentials = string.IsNullOrEmpty(destination.Domain)
? new NetworkCredential(destination.Username, destination.Password)
: new NetworkCredential(destination.Username, destination.Password, destination.Domain);
}
var destinationClient = new AsyncFilesServerClient(destination.ServerUrl, destination.FileSystem,
apiKey: destination.ApiKey, credentials: credentials).Synchronization;
var lastETag = await destinationClient.GetLastSynchronizationFromAsync(storage.Id);
var activeTasks = synchronizationQueue.Active;
var filesNeedConfirmation = GetSyncingConfigurations(destination).Where(sync => activeTasks.All(x => x.FileName != sync.FileName)).ToList();
var confirmations = await ConfirmPushedFiles(filesNeedConfirmation, destinationClient);
var needSyncingAgain = new List<FileHeader>();
foreach (var confirmation in confirmations)
{
if (confirmation.Status == FileStatus.Safe)
{
Log.Debug("Destination server {0} said that file '{1}' is safe", destination, confirmation.FileName);
RemoveSyncingConfiguration(confirmation.FileName, destination.Url);
}
else
{
storage.Batch(accessor =>
{
var fileHeader = accessor.ReadFile(confirmation.FileName);
if (fileHeader != null)
{
needSyncingAgain.Add(fileHeader);
Log.Debug("Destination server {0} said that file '{1}' is {2}.", destination, confirmation.FileName, confirmation.Status);
}
});
}
}
await EnqueueMissingUpdatesAsync(destinationClient, lastETag, needSyncingAgain);
var reports = await Task.WhenAll(SynchronizePendingFilesAsync(destination, destinationClient, forceSyncingContinuation));
var destinationSyncResult = new DestinationSyncResult
{
DestinationServer = destination.ServerUrl,
DestinationFileSystem = destination.FileSystem
};
if (reports.Length > 0)
{
var successfulSynchronizationsCount = reports.Count(x => x.Exception == null);
var failedSynchronizationsCount = reports.Count(x => x.Exception != null);
if (successfulSynchronizationsCount > 0 || failedSynchronizationsCount > 0)
{
Log.Debug(
"Synchronization to a destination {0} has completed. {1} file(s) were synchronized successfully, {2} synchronization(s) were failed",
destination.Url, successfulSynchronizationsCount, failedSynchronizationsCount);
}
destinationSyncResult.Reports = reports;
}
return destinationSyncResult;
}
catch (Exception ex)
{
Log.WarnException(string.Format("Failed to perform a synchronization to a destination {0}", destination), ex);
return new DestinationSyncResult
{
DestinationServer = destination.ServerUrl,
DestinationFileSystem = destination.FileSystem,
Exception = ex
};
}
}
public async Task ShouldThrowWhenUsedApiKeyDefinitionDoesNotContainFileSystem()
{
var client = NewAsyncClient(enableAuthentication: true, apiKey: apiKey);
var server = GetServer();
await client.UploadAsync("abc.bin", new RandomStream(3));
using (var anotherClient = new AsyncFilesServerClient(GetServerUrl(false, server.SystemDatabase.ServerUrl), "ShouldThrow_ApiKeyDoesnContainsThisFS", apiKey: apiKey))
{
await anotherClient.EnsureFileSystemExistsAsync(); // will pass because by using this api key we have access to <system> database
ErrorResponseException errorResponse = null;
try
{
await anotherClient.UploadAsync("def.bin", new RandomStream(1)); // should throw because a file system ShouldThrow_ApiKeyDoesnContainsThisFS isn't added to ApiKeyDefinition
}
catch (InvalidOperationException ex)
{
errorResponse = ex.InnerException as ErrorResponseException;
}
Assert.NotNull(errorResponse);
Assert.Equal(HttpStatusCode.Forbidden, errorResponse.StatusCode);
}
}
public async Task AdminClientWorkWithOAuthEnabled()
{
var client = (IAsyncFilesCommandsImpl) NewAsyncClient(enableAuthentication: true, apiKey: apiKey);
var adminClient = client.Admin;
await adminClient.CreateFileSystemAsync(new FileSystemDocument
{
Id = "Raven/FileSystem/" + "testName",
Settings =
{
{ Constants.FileSystem.DataDirectory, Path.Combine("~", Path.Combine("FileSystems", "testName"))}
}
}, "testName");
var names = await adminClient.GetNamesAsync();
Assert.Equal(1, names.Length); // will not return 'testName' file system name because used apiKey doesn't have access to a such file system
Assert.Equal("AdminClientWorkWithOAuthEnabled", names[0]);
var stats = await adminClient.GetStatisticsAsync();
Assert.Equal(0, stats.Length); // 0 because our fs aren't active
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, "testName"))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] { 1 }));
}
await adminClient.DeleteFileSystemAsync("testName", true);
}
public async Task AdminClientWorkWithWinAuthEnabled()
{
var client = (IAsyncFilesCommandsImpl)NewAsyncClient(enableAuthentication: true, credentials: new NetworkCredential(FactIfWindowsAuthenticationIsAvailable.Admin.UserName, FactIfWindowsAuthenticationIsAvailable.Admin.Password, FactIfWindowsAuthenticationIsAvailable.Admin.Domain));
var adminClient = client.Admin;
await adminClient.CreateFileSystemAsync(MultiDatabase.CreateFileSystemDocument("testName"), "testName");
using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, "testName", conventions: client.Conventions, credentials: new OperationCredentials(null, new NetworkCredential(FactIfWindowsAuthenticationIsAvailable.Admin.UserName, FactIfWindowsAuthenticationIsAvailable.Admin.Password, FactIfWindowsAuthenticationIsAvailable.Admin.Domain))))
{
await createdFsClient.UploadAsync("foo", new MemoryStream(new byte[] {1}));
}
var names = await adminClient.GetNamesAsync();
Assert.Contains("testName", names);
var stats = await adminClient.GetStatisticsAsync();
Assert.NotNull(stats.FirstOrDefault(x => x.Name == "testName"));
await adminClient.DeleteFileSystemAsync("testName");
names = await adminClient.GetNamesAsync();
Assert.DoesNotContain("testName", names);
}
public IAsyncFilesSession OpenAsyncSession(OpenFilesSessionOptions sessionOptions)
{
AssertInitialized();
EnsureNotClosed();
if (string.IsNullOrWhiteSpace(sessionOptions.FileSystem))
throw new ArgumentException("Filesystem cannot be null, empty or whitespace.", "FileSystem");
var sessionId = Guid.NewGuid();
currentSessionId = sessionId;
try
{
var client = new AsyncFilesServerClient( this.Url, sessionOptions.FileSystem, sessionOptions.Credentials, sessionOptions.ApiKey );
var session = new AsyncFilesSession(this, client, this.Listeners, sessionId);
AfterSessionCreated(session);
return session;
}
finally
{
currentSessionId = null;
}
}
