public byte[] AsBytes()
{
var memoryStream = new MemoryStream();
JsonExtensions.CreateDefaultJsonSerializer().Serialize(new BsonWriter(memoryStream), this);
return(memoryStream.ToArray());
}
public async Task <SynchronizationConfirmation[]> GetConfirmationForFilesAsync(IEnumerable <Tuple <string, Etag> > sentFiles)
{
var requestUriString = string.Format("{0}/synchronization/Confirm", baseUrl);
using (var request = RequestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(this, requestUriString, HttpMethods.Post, Credentials, Conventions)).AddOperationHeaders(OperationsHeaders))
{
try
{
using (var stream = new MemoryStream())
{
var sb = new StringBuilder();
var jw = new JsonTextWriter(new StringWriter(sb));
JsonExtensions.CreateDefaultJsonSerializer().Serialize(jw, sentFiles);
var bytes = Encoding.UTF8.GetBytes(sb.ToString());
await stream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
stream.Position = 0;
await request.WriteAsync(stream).ConfigureAwait(false);
var response = (RavenJArray)await request.ReadResponseJsonAsync().ConfigureAwait(false);
return(response.JsonDeserialization <SynchronizationConfirmation>());
}
}
catch (Exception e)
{
throw e.SimplifyException();
}
}
}
public MapReduceIndex(Directory directory, int id, IndexDefinition indexDefinition,
AbstractViewGenerator viewGenerator, WorkContext context)
: base(directory, id, indexDefinition, viewGenerator, context)
{
jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer();
jsonSerializer.Converters = MapReduceConverters;
}
private Field CreateBinaryFieldWithCaching(string name, byte[] value, Field.Store store, Field.Index index, Field.TermVector termVector)
{
if (value.Length > 1024)
{
throw new ArgumentException("Binary values must be smaller than 1Kb");
}
var cacheKey = new FieldCacheKey(name, null, store, termVector, multipleItemsSameFieldCount.ToArray());
Field field;
var stringWriter = new StringWriter();
JsonExtensions.CreateDefaultJsonSerializer().Serialize(stringWriter, value);
var sb = stringWriter.GetStringBuilder();
sb.Remove(0, 1); // remove prefix "
sb.Remove(sb.Length - 1, 1); // remove postfix "
var val = sb.ToString();
if (fieldsCache.TryGetValue(cacheKey, out field) == false)
{
fieldsCache[cacheKey] = field = new Field(name, val, store, index, termVector);
}
field.SetValue(val);
field.Boost = 1;
field.OmitNorms = true;
return(field);
}
private async Task ImportData(SmugglerImportOptions <FilesConnectionStringOptions> importOptions, string filename)
{
var sw = Stopwatch.StartNew();
var directory = Path.GetDirectoryName(filename);
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
// We open the zip file.
using (var archive = new ZipArchive(File.OpenRead(filename), ZipArchiveMode.Read))
{
var filesLookup = archive.Entries.ToDictionary(x => x.FullName);
var metadataEntry = filesLookup[".metadata"];
using (var streamReader = new StreamReader(metadataEntry.Open()))
{
foreach (var json in streamReader.EnumerateJsonObjects())
{
// For each entry in the metadata file.
var container = serializer.Deserialize <FileContainer>(new StringReader(json));
var entry = filesLookup[container.Key];
using (var dataStream = entry.Open())
{
var header = new FileHeader(container.Key, container.Metadata);
await Operations.PutFiles(header, dataStream, entry.Length);
}
Options.CancelToken.Token.ThrowIfCancellationRequested();
}
Options.CancelToken.Token.ThrowIfCancellationRequested();
}
}
sw.Stop();
}
private IEnumerable <IEnumerable <TimeSeriesAppend> > YieldChangeBatches(Stream requestStream, CancellationTimeout timeout, Action <int> changeTimeSeriesFunc)
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
try
{
using (requestStream)
{
var binaryReader = new BinaryReader(requestStream);
while (true)
{
timeout.ThrowIfCancellationRequested();
int batchSize;
try
{
batchSize = binaryReader.ReadInt32();
}
catch (EndOfStreamException)
{
break;
}
using (var stream = new PartialStream(requestStream, batchSize))
{
yield return(YieldBatchItems(stream, serializer, timeout, changeTimeSeriesFunc));
}
}
}
}
finally
{
requestStream.Close();
}
}
public void Execute(DocumentDatabase database)
{
if (string.IsNullOrEmpty(database.Name) == false)
{
return; // we don't care about tenant databases
}
if (string.Equals(database.Configuration.AuthenticationMode, "OAuth", StringComparison.InvariantCultureIgnoreCase) == false)
{
return; // we don't care if we aren't using oauth
}
var array = database.GetDocumentsWithIdStartingWith("Raven/Users/", 0, 1);
if (array.Length > 0)
{
return; // there is already at least one user in there
}
var pwd = Guid.NewGuid().ToString();
if (database.Configuration.RunInMemory == false)
{
var authConfigPath = Path.Combine(Path.GetDirectoryName(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile), "authentication.config");
File.WriteAllText(authConfigPath,
@"Since no users were found in the database, and the database authentication mode was set to OAuth, the following user was automatically created.
Username: Admin
Password: "******"
You can use those credentials to login to RavenDB.");
logger.Info(@"Since no users were found, and the database authentication mode was set to OAuth, a default user was generated name 'Admin'.
Credentials for this user can be found in the following file: {0}", authConfigPath);
}
var ravenJTokenWriter = new RavenJTokenWriter();
JsonExtensions.CreateDefaultJsonSerializer().Serialize(ravenJTokenWriter, new AuthenticationUser
{
AllowedDatabases = new[] { "*" },
Name = "Admin",
Admin = true
}.SetPassword(pwd));
var userDoc = (RavenJObject)ravenJTokenWriter.Token;
userDoc.Remove("Id");
database.Put("Raven/Users/Admin", null,
userDoc,
new RavenJObject
{
{ Constants.RavenEntityName, "AuthenticationUsers" },
{
Constants.RavenClrType,
typeof(AuthenticationUser).FullName + ", " + typeof(AuthenticationUser).Assembly.GetName().Name
}
}, null);
}
private static RavenJObject GetMapedData(object doc)
{
if (doc is IDynamicJsonObject)
{
return(((IDynamicJsonObject)doc).Inner);
}
return(RavenJObject.FromObject(doc, JsonExtensions.CreateDefaultJsonSerializer()));
}
public static void SetAuthorizationFor(this IDocumentSession session, object entity, DocumentAuthorization documentAuthorization)
{
var metadata = session.Advanced.GetMetadataFor(entity);
var jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer();
jsonSerializer.ContractResolver = session.Advanced.DocumentStore.Conventions.JsonContractResolver;
metadata[RavenDocumentAuthorization] = RavenJObject.FromObject(documentAuthorization, jsonSerializer);
}
public void CanUseMultiQuery()
{
using (GetNewServer())
using (var docStore = new DocumentStore {
Url = "http://localhost:8079"
}.Initialize())
{
using (var session = docStore.OpenSession())
{
session.Store(new User {
Name = "Ayende"
});
session.Store(new User {
Name = "Oren"
});
session.SaveChanges();
}
using (var session = docStore.OpenSession())
{
session.Query <User>()
.Customize(x => x.WaitForNonStaleResults())
.Where(u => u.Name == "Ayende")
.ToArray();
}
var request = (HttpWebRequest)WebRequest.Create("http://localhost:8079/multi_get");
request.Method = "POST";
using (var stream = request.GetRequestStream())
{
var streamWriter = new StreamWriter(stream);
JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, new[]
{
new GetRequest
{
Url = "/indexes/dynamic/Users",
Query = "query=Name:Ayende"
},
new GetRequest
{
Url = "/indexes/dynamic/Users",
Query = "query=Name:Oren"
},
});
streamWriter.Flush();
stream.Flush();
}
using (var resp = request.GetResponse())
using (var stream = resp.GetResponseStream())
{
var result = new StreamReader(stream).ReadToEnd();
Assert.Contains("Ayende", result);
Assert.Contains("Oren", result);
}
}
}
private static string ToQueryString(RavenJObject metadata)
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
var sb = new StringBuilder();
serializer.Serialize(new JsonTextWriter(new StringWriter(sb)), metadata);
return(sb.ToString());
}
public override void Prepare(string id, Guid?resourceManagerId, byte[] recoveryInformation)
{
try
{
EsentTransactionContext context;
if (transactionContexts.TryGetValue(id, out context) == false)
{
var myContext = CreateEsentTransactionContext();
try
{
context = transactionContexts.GetOrAdd(id, myContext);
}
finally
{
if (myContext != context)
{
myContext.Dispose();
}
}
}
List <DocumentInTransactionData> changes = null;
using (storage.SetTransactionContext(context))
{
storage.Batch(accessor =>
{
var itemsToTouch = RunOperationsInTransaction(id, out changes);
context.ItemsToTouch = itemsToTouch;
});
}
if (changes == null)
{
return;
}
// independent storage transaction, will actually commit here
storage.Batch(accessor =>
{
var jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer();
var data = new RavenJObject
{
{
"Changes",
RavenJToken.FromObject(changes, jsonSerializer)
},
{ "ResourceManagerId", resourceManagerId.ToString() }, { "RecoveryInformation", recoveryInformation }
};
accessor.Lists.Set("Raven/Transactions/Pending", id, data, UuidType.DocumentTransactions);
});
}
catch (Exception)
{
Rollback(id);
throw;
}
}
protected static void SerializeError(IHttpContext ctx, object error)
{
var sw = new StreamWriter(ctx.Response.OutputStream);
JsonExtensions.CreateDefaultJsonSerializer().Serialize(new JsonTextWriter(sw)
{
Formatting = Formatting.Indented,
}, error);
sw.Flush();
}
public async Task CanUseMultiQuery()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "Ayende"
});
session.Store(new User {
Name = "Oren"
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
session.Query <User>()
.Customize(x => x.WaitForNonStaleResults())
.Where(u => u.Name == "Ayende")
.ToArray();
}
var request = (HttpWebRequest)WebRequest.Create(store.Url.ForDatabase(store.DefaultDatabase) + "/multi_get");
request.Method = "POST";
using (var stream = await request.GetRequestStreamAsync())
{
var streamWriter = new StreamWriter(stream);
JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, new[]
{
new GetRequest
{
Url = "/indexes/dynamic/Users",
Query = "query=Name:Ayende"
},
new GetRequest
{
Url = "/indexes/dynamic/Users",
Query = "query=Name:Oren"
},
});
streamWriter.Flush();
stream.Flush();
}
using (var resp = await request.GetResponseAsync())
using (var stream = resp.GetResponseStream())
{
var result = new StreamReader(stream).ReadToEnd();
Assert.Contains("Ayende", result);
Assert.Contains("Oren", result);
}
}
}
public async Task <SynchronizationReport> PushChangesAsync(CancellationToken token)
{
token.Register(() => { });//request.Abort() TODO: check this
token.ThrowIfCancellationRequested();
if (sourceStream.CanRead == false)
{
throw new Exception("Stream does not support reading");
}
var baseUrl = synchronizationServerClient.BaseUrl;
var credentials = synchronizationServerClient.Credentials;
var conventions = synchronizationServerClient.Conventions;
var requestParams = new CreateHttpJsonRequestParams(this, baseUrl + "/synchronization/MultipartProceed", "POST", credentials, conventions, timeout: TimeSpan.FromHours(12))
{
DisableRequestCompression = true
};
using (var request = synchronizationServerClient.RequestFactory.CreateHttpJsonRequest(requestParams))
{
request.AddHeaders(sourceMetadata);
request.AddHeader("Content-Type", "multipart/form-data; boundary=" + syncingBoundary);
request.AddHeader("If-None-Match", "\"" + sourceMetadata.Value <string>(Constants.MetadataEtagField) + "\"");
request.AddHeader(SyncingMultipartConstants.FileName, fileName);
request.AddHeader(SyncingMultipartConstants.SourceFileSystemInfo, fileSystemInfo.AsJson());
try
{
await request.WriteAsync(PrepareMultipartContent(token)).ConfigureAwait(false);
var response = await request.ReadResponseJsonAsync().ConfigureAwait(false);
return(JsonExtensions.CreateDefaultJsonSerializer().Deserialize <SynchronizationReport>(new RavenJTokenReader(response)));
}
catch (Exception exception)
{
if (token.IsCancellationRequested)
{
throw new OperationCanceledException(token);
}
var webException = exception as ErrorResponseException;
if (webException != null)
{
webException.SimplifyException();
}
throw;
}
}
}
public HttpResponseMessage InfoPackage()
{
var tempFileName = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
var jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer();
jsonSerializer.Formatting = Formatting.Indented;
using (var file = new FileStream(tempFileName, FileMode.Create))
using (var package = new ZipArchive(file, ZipArchiveMode.Create))
{
var adminStats = package.CreateEntry("admin_stats.txt", CompressionLevel.Optimal);
using (var metricsStream = adminStats.Open())
using (var streamWriter = new StreamWriter(metricsStream))
{
jsonSerializer.Serialize(streamWriter, CreateAdminStats());
streamWriter.Flush();
}
DatabasesLandlord.ForAllDatabases(database =>
{
var prefix = string.IsNullOrWhiteSpace(database.Name) ? "System" : database.Name;
DebugInfoProvider.CreateInfoPackageForDatabase(package, database, RequestManager, prefix + "/");
});
var stacktraceRequsted = GetQueryStringValue("stacktrace");
if (stacktraceRequsted != null)
{
DumpStacktrace(package);
}
}
var response = new HttpResponseMessage();
response.Content = new StreamContent(new FileStream(tempFileName, FileMode.Open, FileAccess.Read))
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = string.Format("Admin-Debug-Info-{0}.zip",SystemTime.UtcNow),
},
ContentType = new MediaTypeHeaderValue("application/octet-stream")
}
};
return(response);
}
finally
{
IOExtensions.DeleteFile(tempFileName);
}
}
static ErrorPersister()
{
Serializer = JsonExtensions.CreateDefaultJsonSerializer();
Serializer.TypeNameHandling = TypeNameHandling.Auto;
JObjectMetadata = RavenJObject.Parse($@"
{{
""Raven-Entity-Name"": ""{FailedMessage.CollectionName}"",
""Raven-Clr-Type"": ""{typeof(FailedMessage).AssemblyQualifiedName}""
}}");
}
public CounterStore()
{
JsonSerializer = JsonExtensions.CreateDefaultJsonSerializer();
JsonRequestFactory = new HttpJsonRequestFactory(Constants.NumberOfCachedRequests);
CountersConvention = new CountersConvention();
Credentials = new OperationCredentials(null, CredentialCache.DefaultNetworkCredentials);
Advanced = new CounterStoreAdvancedOperations(this);
Admin = new CounterStoreAdminOperations(this);
batch = new Lazy <BatchOperationsStore>(() => new BatchOperationsStore(this));
isInitialized = false;
}
public byte[] AsBytes()
{
var memoryStream = new MemoryStream();
var streamWriter = new StreamWriter(memoryStream);
JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, this);
streamWriter.Flush();
return(memoryStream.ToArray());
}
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)));
}
}
}
public static DocumentAuthorization GetAuthorizationFor(this IDocumentSession session, object entity)
{
var metadata = session.Advanced.GetMetadataFor(entity);
var docAuthAsJson = metadata[RavenDocumentAuthorization];
if (docAuthAsJson == null)
{
return(null);
}
var jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer();
jsonSerializer.ContractResolver = session.Advanced.DocumentStore.Conventions.JsonContractResolver;
return(jsonSerializer.Deserialize <DocumentAuthorization>(new RavenJTokenReader(docAuthAsJson)));
}
public async Task <T> ReadJsonObjectAsync <T>()
{
using (var stream = await InnerRequest.Content.ReadAsStreamAsync())
using (var gzipStream = new GZipStream(stream, CompressionMode.Decompress))
using (var streamReader = new StreamReader(stream, GetRequestEncoding()))
{
using (var jsonReader = new JsonTextReader(streamReader))
{
var result = JsonExtensions.CreateDefaultJsonSerializer();
return((T)result.Deserialize(jsonReader, typeof(T)));
}
}
}
public override async Task Run(IDictionary <string, object> websocketContext)
{
var sendAsync = (WebSocketSendAsync)websocketContext["websocket.SendAsync"];
var closeAsync = (WebSocketCloseAsync)websocketContext["websocket.CloseAsync"];
var callCancelled = (CancellationToken)websocketContext["websocket.CallCancelled"];
int statusCode = 200;
string statusMessage = "OK";
try
{
var parser = WebSocketsRequestParser;
await parser.ParseWebSocketRequestAsync(_context.Request.Uri, _context.Request.Query["singleUseAuthToken"]).ConfigureAwait(false);
}
catch (WebSocketsRequestParser.WebSocketRequestValidationException e)
{
statusCode = (int)e.StatusCode;
statusMessage = string.IsNullOrEmpty(e.Message) == false ? e.Message : string.Empty;
}
using (var memoryStream = new MemoryStream())
{
var serializer = JsonExtensions.CreateDefaultJsonSerializer();
await SendMessage(memoryStream, serializer, new { StatusCode = statusCode, StatusMessage = statusMessage, Time = SystemTime.UtcNow }, sendAsync, callCancelled).ConfigureAwait(false);
}
try
{
var buffer = new ArraySegment <byte>(new byte[1024]);
var receiveAsync = (WebSocketReceiveAsync)websocketContext["websocket.ReceiveAsync"];
var receiveResult = await receiveAsync(buffer, callCancelled).ConfigureAwait(false);
if (receiveResult.Item1 == WebSocketCloseMessageType)
{
var clientCloseStatus = (int)websocketContext["websocket.ClientCloseStatus"];
var clientCloseDescription = (string)websocketContext["websocket.ClientCloseDescription"];
if (clientCloseStatus == NormalClosureCode && clientCloseDescription == NormalClosureMessage)
{
await closeAsync(clientCloseStatus, clientCloseDescription, callCancelled).ConfigureAwait(false);
}
}
}
catch (Exception e)
{
Log.WarnException("Error when receiving message from web socket transport", e);
throw;
}
}
public void FileHeaderSerialization()
{
var metadata = new RavenJObject {
{ Constants.LastModified, "2014-07-07T12:00:00.0000000" }, { Constants.FileSystem.RavenFsSize, "128" }
};
var fileHeader = new FileHeader("test1.file", metadata);
var serializedValue = JsonExtensions.ToJObject(fileHeader);
var jr = new RavenJTokenReader(serializedValue);
var deserializedValue = JsonExtensions.CreateDefaultJsonSerializer().Deserialize <FileHeader>(jr);
Assert.NotNull(deserializedValue);
Assert.Equal(fileHeader.Name, deserializedValue.Name);
Assert.Equal(fileHeader.LastModified, deserializedValue.LastModified);
}
public async Task CanUseMultiGetToBatchGetDocumentRequests()
{
using (var store = GetDocumentStore())
{
var docs = $"/databases/{store.DefaultDatabase}/docs";
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "Ayende"
});
session.Store(new User {
Name = "Oren"
});
session.SaveChanges();
}
var request = (HttpWebRequest)WebRequest.Create(store.Url.ForDatabase(store.DefaultDatabase) + "/multi_get");
request.Method = "POST";
using (var stream = await request.GetRequestStreamAsync())
{
var streamWriter = new StreamWriter(stream);
JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, new[]
{
new GetRequest
{
Url = docs,
Query = "?id=users/1"
},
new GetRequest
{
Url = docs,
Query = "?id=users/2"
},
});
streamWriter.Flush();
stream.Flush();
}
using (var resp = await request.GetResponseAsync())
using (var stream = resp.GetResponseStream())
{
var result = new StreamReader(stream).ReadToEnd();
Assert.Contains("Ayende", result);
Assert.Contains("Oren", result);
}
}
}
public void CanUseMultiGetToBatchGetDocumentRequests()
{
using (GetNewServer())
using (var docStore = new DocumentStore {
Url = "http://localhost:8079"
}.Initialize())
{
using (var session = docStore.OpenSession())
{
session.Store(new User {
Name = "Ayende"
});
session.Store(new User {
Name = "Oren"
});
session.SaveChanges();
}
var request = (HttpWebRequest)WebRequest.Create("http://localhost:8079/multi_get");
request.Method = "POST";
using (var stream = request.GetRequestStream())
{
var streamWriter = new StreamWriter(stream);
JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, new[]
{
new GetRequest
{
Url = "/docs/users/1"
},
new GetRequest
{
Url = "/docs/users/2"
},
});
streamWriter.Flush();
stream.Flush();
}
using (var resp = request.GetResponse())
using (var stream = resp.GetResponseStream())
{
var result = new StreamReader(stream).ReadToEnd();
Assert.Contains("Ayende", result);
Assert.Contains("Oren", result);
}
}
}
private RavenJArray PerformBulkOperation(string index, IndexQuery indexQuery, bool allowStale, Func <string, TransactionInformation, object> batchOperation)
{
var array = new RavenJArray();
var bulkIndexQuery = new IndexQuery
{
Query = indexQuery.Query,
Start = indexQuery.Start,
Cutoff = indexQuery.Cutoff,
PageSize = int.MaxValue,
FieldsToFetch = new[] { Constants.DocumentIdFieldName },
SortedFields = indexQuery.SortedFields
};
bool stale;
var queryResults = database.QueryDocumentIds(index, bulkIndexQuery, out stale);
if (stale && allowStale == false)
{
throw new InvalidOperationException(
"Bulk operation cancelled because the index is stale and allowStale is false");
}
const int batchSize = 1024;
using (var enumerator = queryResults.GetEnumerator())
{
while (true)
{
var batchCount = 0;
database.TransactionalStorage.Batch(actions =>
{
while (batchCount < batchSize && enumerator.MoveNext())
{
batchCount++;
var result = batchOperation(enumerator.Current, transactionInformation);
array.Add(RavenJObject.FromObject(result, JsonExtensions.CreateDefaultJsonSerializer()));
}
});
if (batchCount < batchSize)
{
break;
}
}
}
return(array);
}
public void ConflictNotificationSerialization()
{
var metadata = new RavenJObject {
{ Constants.LastModified, "2014-07-07T12:00:00.0000000" }, { Constants.FileSystem.RavenFsSize, "128" }
};
var fileHeader = new FileHeader("test1.file", metadata);
var notification = new ConflictNotification()
{
FileName = "test1.file", SourceServerUrl = "http://destination", RemoteFileHeader = fileHeader, Status = ConflictStatus.Detected
};
var serializedValue = JsonExtensions.ToJObject(notification);
var jr = new RavenJTokenReader(serializedValue);
var deserializedValue = JsonExtensions.CreateDefaultJsonSerializer().Deserialize <ConflictNotification>(jr);
Assert.NotNull(deserializedValue);
}
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));
}
private void HandleDataReuqest(HttpContext context)
{
context.Response.ContentType = "application/json";
var rawIds = context.Request.QueryString.GetValues("id") ??
context.Request.QueryString.GetValues("id[]") ??
Enumerable.Empty <string>();
var ids = rawIds.Select(Guid.Parse);
var items = from documentStore in stores.Keys
from id in ids
let profilingInformation = documentStore.GetProfilingInformationFor(id)
where profilingInformation != null
select jsonFormatterAndFieldsFilterer.Filter(profilingInformation);
var results = items.ToList();
JsonExtensions.CreateDefaultJsonSerializer().Serialize(context.Response.Output, results);
context.Response.Output.Flush();
}