private async Task <RavenJObject> ReadJsonAsync()
{
using (var stream = await Request.Content.ReadAsStreamAsync())
using (var streamReader = new StreamReader(stream))
using (var jsonReader = new RavenJsonTextReader(streamReader))
return(RavenJObject.Load(jsonReader));
}
public async Task <RavenJArray> ReadJsonArrayAsync()
{
using (var stream = await InnerRequest.Content.ReadAsStreamAsync())
using (var streamReader = new StreamReader(stream, GetRequestEncoding()))
using (var jsonReader = new RavenJsonTextReader(streamReader))
return(RavenJArray.Load(jsonReader));
}
public async Task <RavenJObject> ReadJsonAsync()
{
using (var stream = await InnerRequest.Content.ReadAsStreamAsync())
using (var buffered = new BufferedStream(stream))
using (var streamReader = new StreamReader(buffered, GetRequestEncoding()))
using (var jsonReader = new RavenJsonTextReader(streamReader))
return(RavenJObject.Load(jsonReader));
}
private async Task <RavenJObject> Recieve(RavenClientWebSocket webSocket)
{
try
{
if (webSocket.State != WebSocketState.Open)
{
throw new InvalidOperationException(
$"Trying to 'ReceiveAsync' WebSocket while not in Open state. State is {webSocket.State}");
}
using (var ms = new MemoryStream())
{
ArraySegment <byte> bytes;
ms.SetLength(MaxWebSocketRecvSize);
ms.TryGetBuffer(out bytes);
var arraySegment = new ArraySegment <byte>(bytes.Array, 0, MaxWebSocketRecvSize);
var result = await webSocket.ReceiveAsync(arraySegment, disposedToken.Token);
if (result.MessageType == WebSocketMessageType.Close)
{
if (Logger.IsDebugEnabled)
{
Logger.Debug("Client got close message from server and is closing connection");
}
// actual socket close from dispose
return(null);
}
if (result.EndOfMessage == false)
{
var err = $"In Recieve got response longer then {MaxWebSocketRecvSize}";
var ex = new InvalidOperationException(err);
Logger.DebugException(err, ex);
throw ex;
}
using (var reader = new StreamReader(ms, Encoding.UTF8, true, MaxWebSocketRecvSize, true))
using (var jsonReader = new RavenJsonTextReader(reader)
{
SupportMultipleContent = true
})
{
if (jsonReader.Read() == false)
{
throw new InvalidDataException("Couldn't read recieved websocket json message");
}
return(RavenJObject.Load(jsonReader));
}
}
}
catch (WebSocketException ex)
{
Logger.DebugException("Failed to receive a message, client was probably disconnected", ex);
throw;
}
}
protected async Task <RavenJArray> ReadJsonArrayAsync()
{
using (var stream = await InnerRequest.Content.ReadAsStreamAsync().ConfigureAwait(false))
using (var buffered = new BufferedStream(stream))
using (var streamReader = new StreamReader(buffered, GetRequestEncoding()))
using (var jsonReader = new RavenJsonTextReader(streamReader))
{
return(RavenJArray.Load(jsonReader));
}
}
public static RavenJToken TryLoad(Stream stream)
{
var jsonTextReader = new RavenJsonTextReader(new StreamReader(stream));
if (jsonTextReader.Read() == false || jsonTextReader.TokenType == JsonToken.None)
{
return(null);
}
return(Load(jsonTextReader));
}
/// <summary>
/// Load a <see cref="RavenJObject"/> from a string that contains JSON.
/// </summary>
/// <param name="json">A <see cref="String"/> that contains JSON.</param>
/// <returns>A <see cref="RavenJObject"/> populated from the string that contains JSON.</returns>
public new static RavenJObject Parse(string json)
{
try
{
JsonReader jsonReader = new RavenJsonTextReader(new StringReader(json));
return(Load(jsonReader));
}
catch (Exception e)
{
throw new InvalidOperationException("Could not parse json:" + Environment.NewLine + json, e);
}
}
/// <summary>
/// Load a <see cref="RavenJToken"/> from a string that contains JSON.
/// </summary>
/// <param name="json">A <see cref="String"/> that contains JSON.</param>
/// <returns>A <see cref="RavenJToken"/> populated from the string that contains JSON.</returns>
public static RavenJToken Parse(string json)
{
try
{
JsonReader jsonReader = new RavenJsonTextReader(new StringReader(json));
return(Load(jsonReader));
}
catch (Exception e)
{
throw new JsonSerializationException("Could not parse: [" + json + "]", e);
}
}
public static T ReadJsonObject <T>(this IHttpContext context)
{
using (var streamReader = new StreamReader(context.Request.InputStream, GetRequestEncoding(context)))
{
var readToEnd = streamReader.ReadToEnd();
using (var jsonReader = new RavenJsonTextReader(new StringReader(readToEnd)))
{
var result = JsonExtensions.CreateDefaultJsonSerializer();
return((T)result.Deserialize(jsonReader, typeof(T)));
}
}
}
/// <summary>
/// Convert a byte array to a RavenJObject
/// </summary>
public static RavenJObject ToJObject(this Stream self)
{
var streamWithCachedHeader = new StreamWithCachedHeader(self, 3);
if (IsJson(streamWithCachedHeader))
{
using (var streamReader = new StreamReader(streamWithCachedHeader, Encoding.UTF8, false, 1024, true))
using (var jsonReader = new RavenJsonTextReader(streamReader))
{
return(RavenJObject.Load(jsonReader));
}
}
return(RavenJObject.Load(new BsonReader(streamWithCachedHeader)
{
DateTimeKindHandling = DateTimeKind.Utc,
}));
}
public Task <HttpResponseMessage> ExportDatabase(ExportData smugglerOptionsJson)
{
var requestString = smugglerOptionsJson.SmugglerOptions;
SmugglerDatabaseOptions smugglerOptions;
using (var jsonReader = new RavenJsonTextReader(new StringReader(requestString)))
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
smugglerOptions = (SmugglerDatabaseOptions)serializer.Deserialize(jsonReader, typeof(SmugglerDatabaseOptions));
}
var result = GetEmptyMessage();
// create PushStreamContent object that will be called when the output stream will be ready.
result.Content = new PushStreamContent(async(outputStream, content, arg3) =>
{
try
{
var dataDumper = new DatabaseDataDumper(Database, smugglerOptions);
await dataDumper.ExportData(
new SmugglerExportOptions <RavenConnectionStringOptions>
{
ToStream = outputStream
}).ConfigureAwait(false);
}
finally
{
outputStream.Close();
}
});
var fileName = String.IsNullOrEmpty(smugglerOptions.NoneDefualtFileName) || (smugglerOptions.NoneDefualtFileName.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0) ?
string.Format("Dump of {0}, {1}", this.DatabaseName, DateTime.Now.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture)) :
smugglerOptions.NoneDefualtFileName;
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = fileName + ".ravendump"
};
return(new CompletedTask <HttpResponseMessage>(result));
}
public static bool TryGetJsonReaderForStream(Stream stream, out JsonTextReader jsonTextReader, out CountingStream sizeStream)
{
jsonTextReader = null;
sizeStream = null;
try
{
stream.Position = 0;
sizeStream = new CountingStream(new GZipStream(stream, CompressionMode.Decompress));
var streamReader = new StreamReader(sizeStream);
jsonTextReader = new RavenJsonTextReader(streamReader);
if (jsonTextReader.Read() == false)
{
return(false);
}
}
catch (Exception e)
{
if (e is InvalidDataException == false)
{
if (sizeStream != null)
{
sizeStream.Dispose();
}
throw;
}
stream.Seek(0, SeekOrigin.Begin);
sizeStream = new CountingStream(stream);
var streamReader = new StreamReader(sizeStream);
jsonTextReader = new JsonTextReader(streamReader);
if (jsonTextReader.Read() == false)
{
return(false);
}
}
return(true);
}
public Task <HttpResponseMessage> ExportFilesystem(StudioTasksController.ExportData exportData)
{
var requestString = exportData.SmugglerOptions;
FileSystemSmugglerOptions options;
using (var jsonReader = new RavenJsonTextReader(new StringReader(requestString)))
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
options = (FileSystemSmugglerOptions)serializer.Deserialize(jsonReader, typeof(FileSystemSmugglerOptions));
}
var result = GetEmptyMessage();
// create PushStreamContent object that will be called when the output stream will be ready.
result.Content = new PushStreamContent((outputStream, content, arg3) =>
{
try
{
var smuggler = new FileSystemSmuggler(options);
return(smuggler.ExecuteAsync(new EmbeddedSmugglingSource(FileSystem), new StreamSmugglingDestination(outputStream, leaveOpen: true)));
}
finally
{
outputStream.Close();
}
});
var fileName = string.IsNullOrEmpty(exportData.FileName) || (exportData.FileName.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0) ?
string.Format("Dump of {0}, {1}", FileSystemName, DateTime.Now.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture)) :
exportData.FileName;
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = fileName + ".ravendump"
};
return(new CompletedTask <HttpResponseMessage>(result));
}
public async Task <HttpResponseMessage> ExportDatabase(ExportData smugglerOptionsJson)
{
var requestString = smugglerOptionsJson.SmugglerOptions;
SmugglerOptions smugglerOptions;
using (var jsonReader = new RavenJsonTextReader(new StringReader(requestString)))
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
smugglerOptions = (SmugglerOptions)serializer.Deserialize(jsonReader, typeof(SmugglerOptions));
}
var result = GetEmptyMessage();
// create PushStreamContent object that will be called when the output stream will be ready.
result.Content = new PushStreamContent(async(outputStream, content, arg3) =>
{
try
{
await new DataDumper(Database).ExportData(new SmugglerExportOptions
{
ToStream = outputStream
}, smugglerOptions).ConfigureAwait(false);
}
// close the output stream, so the PushStremContent mechanism will know that the process is finished
finally
{
outputStream.Close();
}
});
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = "Dump of " + this.DatabaseName + ", " + DateTime.Now.ToString("dd MMM yyyy HH-mm")
};
return(result);
}
public Task <HttpResponseMessage> ExportDatabase([FromBody] ExportData exportData)
{
var requestString = exportData.SmugglerOptions;
DatabaseSmugglerOptions smugglerOptions;
using (var jsonReader = new RavenJsonTextReader(new StringReader(requestString)))
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
smugglerOptions = (DatabaseSmugglerOptions)serializer.Deserialize(jsonReader, typeof(DatabaseSmugglerOptions));
}
var result = GetEmptyMessage();
// create PushStreamContent object that will be called when the output stream will be ready.
result.Content = new PushStreamContent(async(outputStream, content, arg3) =>
{
try
{
var smuggler = new DatabaseSmuggler(smugglerOptions, new DatabaseSmugglerEmbeddedSource(Database), new DatabaseSmugglerStreamDestination(outputStream, leaveOpen: true));
await smuggler.ExecuteAsync().ConfigureAwait(false);
}
finally
{
outputStream.Close();
}
});
var fileName = string.IsNullOrEmpty(exportData.FileName) || (exportData.FileName.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0) ?
string.Format("Dump of {0}, {1}", DatabaseName, DateTime.Now.ToString("yyyy-MM-dd HH-mm")) :
exportData.FileName;
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = fileName + ".ravendump"
};
return(new CompletedTask <HttpResponseMessage>(result));
}
public Task <HttpResponseMessage> ExportDatabase(ExportData smugglerOptionsJson)
{
var requestString = smugglerOptionsJson.SmugglerOptions;
SmugglerOptions smugglerOptions;
using (var jsonReader = new RavenJsonTextReader(new StringReader(requestString)))
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
smugglerOptions = (SmugglerOptions)serializer.Deserialize(jsonReader, typeof(SmugglerOptions));
}
var result = GetEmptyMessage();
// create PushStreamContent object that will be called when the output stream will be ready.
result.Content = new PushStreamContent(async(outputStream, content, arg3) =>
{
try
{
await new DataDumper(Database).ExportData(new SmugglerExportOptions
{
ToStream = outputStream
}, smugglerOptions).ConfigureAwait(false);
}
finally
{
outputStream.Close();
}
});
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = string.Format("Dump of {0}, {1}.ravendump", this.DatabaseName, DateTime.Now.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture))
};
return(new CompletedTask <HttpResponseMessage>(result));
}
private async Task Receive()
{
try
{
using (var ms = new MemoryStream())
{
ms.SetLength(4096);
while (webSocket.State == WebSocketState.Open)
{
if (ms.Length > 4096 * 16)
{
ms.SetLength(4096);
}
ms.Position = 0;
ArraySegment <byte> bytes;
ms.TryGetBuffer(out bytes);
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(bytes.Array, (int)ms.Position, (int)(ms.Length - ms.Position)),
disposedToken.Token);
ms.Position = result.Count;
if (result.MessageType == WebSocketMessageType.Close)
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
return;
}
while (result.EndOfMessage == false)
{
if (ms.Length - ms.Position < 1024)
{
ms.SetLength(ms.Length + 4096);
}
ms.TryGetBuffer(out bytes);
result = await webSocket.ReceiveAsync(new ArraySegment <byte>(bytes.Array, (int)ms.Position, (int)(ms.Length - ms.Position)), CancellationToken.None);
ms.Position += result.Count;
}
ms.SetLength(ms.Position);
ms.Position = 0;
using (var reader = new StreamReader(ms, Encoding.UTF8, true, 1024, true))
using (var jsonReader = new RavenJsonTextReader(reader)
{
SupportMultipleContent = true
})
while (jsonReader.Read())
{
var ravenJObject = RavenJObject.Load(jsonReader);
HandleRevicedNotification(ravenJObject);
}
}
}
}
catch (WebSocketException ex)
{
logger.DebugException("Failed to receive a message, client was probably disconnected", ex);
}
}
public static RavenJArray ReadJsonArray(this IHttpContext context)
{
using (var streamReader = new StreamReader(context.Request.InputStream, GetRequestEncoding(context)))
using (var jsonReader = new RavenJsonTextReader(streamReader))
return(RavenJArray.Load(jsonReader));
}
public Task <HttpResponseMessage> ExportDocumentsLeftToReplicate([FromBody] StudioTasksController.ExportData optionsJson)
{
var result = GetEmptyMessage();
var taskId = optionsJson.ProgressTaskId;
var status = new OperationStatus();
var tcs = new TaskCompletionSource <object>();
try
{
var sp = Stopwatch.StartNew();
Database.Tasks.AddTask(tcs.Task, status, new TaskActions.PendingTaskDescription
{
StartTime = SystemTime.UtcNow,
TaskType = TaskActions.PendingTaskType.ExportDocumentsLeftToReplicate,
Description = "Monitoring progress of export of docs left to replicate"
}, taskId, null, skipStatusCheck: true);
var requestString = optionsJson.DownloadOptions;
ServerInfo serverInfo;
using (var jsonReader = new RavenJsonTextReader(new StringReader(requestString)))
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
serverInfo = (ServerInfo)serializer.Deserialize(jsonReader, typeof(ServerInfo));
}
var documentsToReplicateCalculator = new DocumentsLeftToReplicate(Database);
if (serverInfo.SourceId != documentsToReplicateCalculator.DatabaseId)
{
throw new InvalidOperationException("Cannot export documents to replicate from a server other than this one!");
}
// create PushStreamContent object that will be called when the output stream will be ready.
result.Content = new PushStreamContent((outputStream, content, arg3) =>
{
using (var writer = new ExcelOutputWriter(outputStream))
{
try
{
writer.WriteHeader();
writer.Write("document-ids-left-to-replicate");
long count = 0;
long skipped = 0;
Action <string> action = (documentId) =>
{
writer.Write(documentId);
if (++count % 1000 != 0)
{
return;
}
status.MarkProgress($"Exported {count:#,#} documents");
outputStream.Flush();
};
Action skippedAction = () =>
{
if (++skipped % 100 != 0)
{
return;
}
status.MarkProgress($"Skipped {skipped:#,#} documents");
outputStream.Flush();
};
documentsToReplicateCalculator.ExtractDocumentIds(serverInfo, action, skippedAction);
var message = $"Completed export of {count:#,#} document ids";
status.MarkCompleted(message, sp.Elapsed);
}
catch (Exception e)
{
status.ExceptionDetails = e.ToString();
status.MarkFaulted(e.ToString());
writer.WriteError(e);
throw;
}
finally
{
tcs.SetResult("Completed");
outputStream.Close();
}
}
});
var fileName = $"Documents to replicate from '{serverInfo.SourceUrl}' to '{serverInfo.DestinationUrl}', " +
$"{DateTime.Now.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture)}";
foreach (char c in Path.GetInvalidFileNameChars())
{
fileName = fileName.Replace(c, '_');
}
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = fileName + ".csv"
};
}
catch (Exception e)
{
status.ExceptionDetails = e.ToString();
status.MarkFaulted(e.ToString());
tcs.SetResult("Completed");
throw;
}
return(new CompletedTask <HttpResponseMessage>(result));
}
public static T Convert <T>(object value, bool cast)
{
if (cast)
{
// HACK
return((T)value);
}
if (value == null)
{
return(default(T));
}
if (value is T)
{
return((T)value);
}
Type targetType = typeof(T);
if (targetType.GetTypeInfo().IsGenericType&& targetType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
targetType = Nullable.GetUnderlyingType(targetType);
}
if (targetType == typeof(Guid))
{
return((T)(object)new Guid(value.ToString()));
}
if (targetType == typeof(string))
{
return((T)(object)value.ToString());
}
if (targetType == typeof(DateTime))
{
if (value is DateTimeOffset)
{
return((T)(object)((DateTimeOffset)value).DateTime);
}
var s = value as string;
if (s == null)
{
var lzv = value as LazyStringValue;
if (lzv != null)
{
s = lzv;
}
}
if (s != null)
{
DateTime dateTime;
if (DateTime.TryParseExact(s, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind, out dateTime))
{
return((T)(object)dateTime);
}
dateTime = RavenJsonTextReader.ParseDateMicrosoft(s);
return((T)(object)dateTime);
}
}
if (targetType == typeof(DateTimeOffset))
{
var s = value as string ?? value as LazyStringValue;
if (s != null)
{
DateTimeOffset dateTimeOffset;
if (DateTimeOffset.TryParseExact(s, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind, out dateTimeOffset))
{
return((T)(object)dateTimeOffset);
}
return(default(T));
}
}
var lsv = value as LazyStringValue;
if (lsv != null)
{
value = (string)lsv;
}
try
{
return((T)System.Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture));
}
catch (Exception e)
{
throw new InvalidOperationException(string.Format("Unable to find suitable conversion for {0} since it is not predefined ", value), e);
}
}
internal static U Convert <U>(this RavenJToken token, bool cast)
{
if (cast)
{
// HACK
return((U)(object)token);
}
if (token == null)
{
return(default(U));
}
var value = token as RavenJValue;
if (value == null)
{
throw new InvalidCastException("Cannot cast {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, token.GetType(), typeof(U)));
}
if (value.Value is U)
{
return((U)value.Value);
}
Type targetType = typeof(U);
if (targetType.IsGenericType && targetType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
if (value.Value == null)
{
return(default(U));
}
targetType = Nullable.GetUnderlyingType(targetType);
}
if (targetType == typeof(Guid))
{
if (value.Value == null)
{
return(default(U));
}
return((U)(object)new Guid(value.Value.ToString()));
}
if (targetType == typeof(string))
{
if (value.Value == null)
{
return(default(U));
}
return((U)(object)value.Value.ToString());
}
if (targetType == typeof(DateTime) && value.Value is string)
{
DateTime dateTime;
if (DateTime.TryParseExact((string)value.Value, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateTime))
{
return((U)(object)dateTime);
}
dateTime = RavenJsonTextReader.ParseDateMicrosoft((string)value.Value);
return((U)(object)dateTime);
}
return((U)System.Convert.ChangeType(value.Value, targetType, CultureInfo.InvariantCulture));
}
public async virtual Task ImportData(SmugglerImportOptions <RavenConnectionStringOptions> importOptions, Stream stream)
{
Operations.Configure(Options);
Operations.Initialize(Options);
await DetectServerSupportedFeatures(importOptions.To);
Stream sizeStream;
var sw = Stopwatch.StartNew();
// Try to read the stream compressed, otherwise continue uncompressed.
JsonTextReader jsonReader;
try
{
stream.Position = 0;
sizeStream = new CountingStream(new GZipStream(stream, CompressionMode.Decompress));
var streamReader = new StreamReader(sizeStream);
jsonReader = new RavenJsonTextReader(streamReader);
if (jsonReader.Read() == false)
{
return;
}
}
catch (Exception e)
{
if (e is InvalidDataException == false)
{
throw;
}
stream.Seek(0, SeekOrigin.Begin);
sizeStream = new CountingStream(stream);
var streamReader = new StreamReader(sizeStream);
jsonReader = new JsonTextReader(streamReader);
if (jsonReader.Read() == false)
{
return;
}
}
if (jsonReader.TokenType != JsonToken.StartObject)
{
throw new InvalidDataException("StartObject was expected");
}
var exportCounts = new Dictionary <string, int>();
var exportSectionRegistar = new Dictionary <string, Func <int> >();
Options.CancelToken.Token.ThrowIfCancellationRequested();
exportSectionRegistar.Add("Indexes", () =>
{
Operations.ShowProgress("Begin reading indexes");
var indexCount = ImportIndexes(jsonReader).Result;
Operations.ShowProgress(string.Format("Done with reading indexes, total: {0}", indexCount));
return(indexCount);
});
exportSectionRegistar.Add("Docs", () =>
{
Operations.ShowProgress("Begin reading documents");
var documentCount = ImportDocuments(jsonReader).Result;
Operations.ShowProgress(string.Format("Done with reading documents, total: {0}", documentCount));
return(documentCount);
});
exportSectionRegistar.Add("Attachments", () =>
{
Operations.ShowProgress("Begin reading attachments");
var attachmentCount = ImportAttachments(importOptions.To, jsonReader).Result;
Operations.ShowProgress(string.Format("Done with reading attachments, total: {0}", attachmentCount));
return(attachmentCount);
});
exportSectionRegistar.Add("Transformers", () =>
{
Operations.ShowProgress("Begin reading transformers");
var transformersCount = ImportTransformers(jsonReader).Result;
Operations.ShowProgress(string.Format("Done with reading transformers, total: {0}", transformersCount));
return(transformersCount);
});
exportSectionRegistar.Add("DocsDeletions", () =>
{
Operations.ShowProgress("Begin reading deleted documents");
var deletedDocumentsCount = ImportDeletedDocuments(jsonReader).Result;
Operations.ShowProgress(string.Format("Done with reading deleted documents, total: {0}", deletedDocumentsCount));
return(deletedDocumentsCount);
});
exportSectionRegistar.Add("AttachmentsDeletions", () =>
{
Operations.ShowProgress("Begin reading deleted attachments");
var deletedAttachmentsCount = ImportDeletedAttachments(jsonReader).Result;
Operations.ShowProgress(string.Format("Done with reading deleted attachments, total: {0}", deletedAttachmentsCount));
return(deletedAttachmentsCount);
});
exportSectionRegistar.Add("Identities", () =>
{
Operations.ShowProgress("Begin reading identities");
var identitiesCount = ImportIdentities(jsonReader).Result;
Operations.ShowProgress(string.Format("Done with reading identities, total: {0}", identitiesCount));
return(identitiesCount);
});
exportSectionRegistar.Keys.ForEach(k => exportCounts[k] = 0);
while (jsonReader.Read() && jsonReader.TokenType != JsonToken.EndObject)
{
Options.CancelToken.Token.ThrowIfCancellationRequested();
if (jsonReader.TokenType != JsonToken.PropertyName)
{
throw new InvalidDataException("PropertyName was expected");
}
Func <int> currentAction;
var currentSection = jsonReader.Value.ToString();
if (exportSectionRegistar.TryGetValue(currentSection, out currentAction) == false)
{
throw new InvalidDataException("Unexpected property found: " + jsonReader.Value);
}
if (jsonReader.Read() == false)
{
exportCounts[currentSection] = 0;
continue;
}
if (jsonReader.TokenType != JsonToken.StartArray)
{
throw new InvalidDataException("StartArray was expected");
}
exportCounts[currentSection] = currentAction();
}
sw.Stop();
Operations.ShowProgress("Imported {0:#,#;;0} documents and {1:#,#;;0} attachments, deleted {2:#,#;;0} documents and {3:#,#;;0} attachments in {4:#,#.###;;0} s", exportCounts["Docs"], exportCounts["Attachments"], exportCounts["DocsDeletions"], exportCounts["AttachmentsDeletions"], sw.ElapsedMilliseconds / 1000f);
Options.CancelToken.Token.ThrowIfCancellationRequested();
}
internal static U Convert <U>(this RavenJToken token, bool cast)
{
if (cast)
{
// HACK
return((U)(object)token);
}
if (token == null || token.Type == JTokenType.Null)
{
return(default(U));
}
var value = token as RavenJValue;
if (value == null)
{
throw new InvalidCastException("Cannot cast {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, token.GetType(), typeof(U)));
}
if (value.Value is U)
{
return((U)value.Value);
}
Type targetType = typeof(U);
if (targetType.IsGenericType() && targetType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
if (value.Value == null)
{
return(default(U));
}
targetType = Nullable.GetUnderlyingType(targetType);
}
if (targetType == typeof(Guid))
{
if (value.Value == null)
{
return(default(U));
}
return((U)(object)new Guid(value.Value.ToString()));
}
if (targetType == typeof(string))
{
if (value.Value == null)
{
return(default(U));
}
return((U)(object)value.Value.ToString());
}
if (targetType == typeof(DateTime))
{
var s = value.Value as string;
if (s != null)
{
DateTime dateTime;
if (DateTime.TryParseExact(s, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind, out dateTime))
{
return((U)(object)dateTime);
}
dateTime = RavenJsonTextReader.ParseDateMicrosoft(s);
return((U)(object)dateTime);
}
if (value.Value is DateTimeOffset)
{
return((U)(object)((DateTimeOffset)value.Value).UtcDateTime);
}
}
if (targetType == typeof(DateTimeOffset))
{
var s = value.Value as string;
if (s != null)
{
DateTimeOffset dateTimeOffset;
if (DateTimeOffset.TryParseExact(s, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind, out dateTimeOffset))
{
return((U)(object)dateTimeOffset);
}
return(default(U));
}
if (value.Value is DateTime)
{
return((U)(object)(new DateTimeOffset((DateTime)value.Value)));
}
}
if (targetType == typeof(byte[]) && value.Value is string)
{
return((U)(object)System.Convert.FromBase64String((string)value.Value));
}
if (value.Value == null && typeof(U).IsValueType)
{
throw new InvalidOperationException("value.Value == null and conversion target type is not nullable");
}
try
{
return((U)System.Convert.ChangeType(value.Value, targetType, CultureInfo.InvariantCulture));
}
catch (Exception e)
{
if (value.Value != null)
{
throw new InvalidOperationException(string.Format("Unable to find suitable conversion for {0} since it is not predefined and does not implement IConvertible. ", value.Value.GetType()), e);
}
throw new InvalidOperationException(string.Format("Unable to find suitable conversion for {0} since it is not predefined ", value), e);
}
}
public Task <HttpResponseMessage> ExportFilesystem(StudioTasksController.ExportData smugglerOptionsJson)
{
var result = GetEmptyMessage();
var taskId = smugglerOptionsJson.ProgressTaskId;
var requestString = smugglerOptionsJson.DownloadOptions;
SmugglerFilesOptions smugglerOptions;
using (var jsonReader = new RavenJsonTextReader(new StringReader(requestString)))
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
smugglerOptions = (SmugglerFilesOptions)serializer.Deserialize(jsonReader, typeof(SmugglerFilesOptions));
}
var fileName = string.IsNullOrEmpty(smugglerOptions.NoneDefualtFileName) || (smugglerOptions.NoneDefualtFileName.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0) ?
$"Dump of {FileSystemName}, {DateTime.Now.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture)}" :
smugglerOptions.NoneDefualtFileName;
//create PushStreamContent object that will be called when the output stream will be ready.
result.Content = new PushStreamContent(async(outputStream, content, arg3) =>
{
var status = new DataDumperOperationStatus();
var tcs = new TaskCompletionSource <object>();
var sp = Stopwatch.StartNew();
try
{
FileSystem.Tasks.AddTask(tcs.Task, status, new TaskActions.PendingTaskDescription
{
StartTime = SystemTime.UtcNow,
TaskType = TaskActions.PendingTaskType.ExportFileSystem,
Payload = "Exporting file system, file name: " + fileName
}, taskId, smugglerOptions.CancelToken, skipStatusCheck: true);
var dataDumper = new FilesystemDataDumper(FileSystem, smugglerOptions);
dataDumper.Progress += s => status.MarkProgress(s);
await dataDumper.ExportData(
new SmugglerExportOptions <FilesConnectionStringOptions>
{
ToStream = outputStream
}).ConfigureAwait(false);
const string message = "Completed export";
status.MarkCompleted(message, sp.Elapsed);
}
catch (OperationCanceledException e)
{
status.MarkCanceled(e.Message);
}
catch (Exception e)
{
status.ExceptionDetails = e.ToString();
status.MarkFaulted(e.ToString());
throw;
}
finally
{
tcs.SetResult("Completed");
outputStream.Close();
}
});
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = fileName + ".ravenfsdump"
};
return(new CompletedTask <HttpResponseMessage>(result));
}
private static RavenJToken ParseInternal(string json)
{
JsonReader jsonReader = new RavenJsonTextReader(new StringReader(json));
return(Load(jsonReader));
}
