public HttpResponseMessage Compact()
{
var db = InnerRequest.RequestUri.ParseQueryString()["database"];
if (string.IsNullOrWhiteSpace(db))
{
return(GetMessageWithString("Compact request requires a valid database parameter", HttpStatusCode.BadRequest));
}
var configuration = DatabasesLandlord.CreateTenantConfiguration(db);
if (configuration == null)
{
return(GetMessageWithString("No database named: " + db, HttpStatusCode.NotFound));
}
try
{
var targetDb = DatabasesLandlord.GetDatabaseInternal(db).ResultUnwrap();
DatabasesLandlord.Lock(db, () => targetDb.TransactionalStorage.Compact(configuration));
return(GetEmptyMessage());
}
catch (NotSupportedException e)
{
return(GetMessageWithString(e.Message, HttpStatusCode.BadRequest));
}
}
private async Task <HttpResponseMessage> ExecuteActualRequest(HttpControllerContext controllerContext, CancellationToken cancellationToken,
MixedModeRequestAuthorizer authorizer)
{
HttpResponseMessage authMsg;
if (authorizer.TryAuthorize(this, out authMsg) == false)
{
return(authMsg);
}
var internalHeader = GetHeader("Raven-internal-request");
if (internalHeader == null || internalHeader != "true")
{
RequestManager.IncrementRequestCount();
}
if (DatabaseName != null && await DatabasesLandlord.GetDatabaseInternal(DatabaseName) == null)
{
var msg = "Could not find a database named: " + DatabaseName;
return(GetMessageWithObject(new { Error = msg }, HttpStatusCode.ServiceUnavailable));
}
var sp = Stopwatch.StartNew();
var result = await base.ExecuteAsync(controllerContext, cancellationToken);
sp.Stop();
AddRavenHeader(result, sp);
return(result);
}
public override async Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
InnerInitialization(controllerContext);
DocumentDatabase db;
try
{
db = await DatabasesLandlord.GetDatabaseInternal(DatabaseName);
}
catch (Exception e)
{
return(GetMessageWithObject(new
{
Error = "Could not open database named: " + DatabaseName + ", " + e.Message
}, HttpStatusCode.ServiceUnavailable));
}
if (db == null)
{
return(GetMessageWithObject(new
{
Error = "Could not open database named: " + DatabaseName + ", database does not exists"
}, HttpStatusCode.ServiceUnavailable));
}
if (db.Configuration == null || db.Configuration.ActiveBundles == null ||
!db.Configuration.ActiveBundles.Any(activeBundleName => activeBundleName.Equals(BundleName, StringComparison.InvariantCultureIgnoreCase)))
{
return(GetMessageWithObject(new
{
Error = "Could not figure out what to do"
}, HttpStatusCode.BadRequest));
}
return(await base.ExecuteAsync(controllerContext, cancellationToken));
}
private async Task <HttpResponseMessage> ExecuteActualRequest(HttpControllerContext controllerContext, CancellationToken cancellationToken,
MixedModeRequestAuthorizer authorizer)
{
if (SkipAuthorizationSinceThisIsMultiGetRequestAlreadyAuthorized == false)
{
HttpResponseMessage authMsg;
if (authorizer.TryAuthorize(this, out authMsg) == false)
{
return(authMsg);
}
}
if (IsInternalRequest == false)
{
RequestManager.IncrementRequestCount();
}
if (DatabaseName != null && await DatabasesLandlord.GetDatabaseInternal(DatabaseName) == null)
{
var msg = "Could not find a database named: " + DatabaseName;
return(GetMessageWithObject(new { Error = msg }, HttpStatusCode.ServiceUnavailable));
}
var sp = Stopwatch.StartNew();
controllerContext.RequestContext.Principal = CurrentOperationContext.User.Value;
var result = await base.ExecuteAsync(controllerContext, cancellationToken);
sp.Stop();
AddRavenHeader(result, sp);
return(result);
}
public override async Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
InnerInitialization(controllerContext);
var db = await DatabasesLandlord.GetDatabaseInternal(DatabaseName);
if (!db.Configuration.ActiveBundles.Any(activeBundleName => activeBundleName.Equals(BundleName, StringComparison.InvariantCultureIgnoreCase)))
{
return(GetMessageWithObject(new
{
Error = "Could not figure out what to do"
}, HttpStatusCode.BadRequest));
}
return(await base.ExecuteAsync(controllerContext, cancellationToken));
}
public HttpResponseMessage Compact()
{
var db = InnerRequest.RequestUri.ParseQueryString()["database"];
if (string.IsNullOrWhiteSpace(db))
{
return(GetMessageWithString("Compact request requires a valid database parameter", HttpStatusCode.BadRequest));
}
var configuration = DatabasesLandlord.CreateTenantConfiguration(db);
if (configuration == null)
{
return(GetMessageWithString("No database named: " + db, HttpStatusCode.NotFound));
}
var task = Task.Factory.StartNew(() =>
{
// as we perform compact async we don't catch exceptions here - they will be propaged to operation
var targetDb = DatabasesLandlord.GetDatabaseInternal(db).ResultUnwrap();
DatabasesLandlord.Lock(db, () => targetDb.TransactionalStorage.Compact(configuration));
return(GetEmptyMessage());
});
long id;
Database.Tasks.AddTask(task, new TaskBasedOperationState(task), new TaskActions.PendingTaskDescription
{
StartTime = SystemTime.UtcNow,
TaskType = TaskActions.PendingTaskType.CompactDatabase,
Payload = "Compact database " + db,
}, out id);
return(GetMessageWithObject(new
{
OperationId = id
}));
}
public HttpResponseMessage Compact()
{
var db = InnerRequest.RequestUri.ParseQueryString()["database"];
if (string.IsNullOrWhiteSpace(db))
{
return(GetMessageWithString("Compact request requires a valid database parameter", HttpStatusCode.BadRequest));
}
var configuration = DatabasesLandlord.CreateTenantConfiguration(db);
if (configuration == null)
{
return(GetMessageWithString("No database named: " + db, HttpStatusCode.NotFound));
}
var task = Task.Factory.StartNew(() =>
{
var compactStatus = new CompactStatus {
State = CompactStatusState.Running, Messages = new List <string>()
};
DatabasesLandlord.SystemDatabase.Documents.Delete(CompactStatus.RavenDatabaseCompactStatusDocumentKey(db), null, null);
try
{
var targetDb = DatabasesLandlord.GetDatabaseInternal(db).ResultUnwrap();
DatabasesLandlord.Lock(db, () => targetDb.TransactionalStorage.Compact(configuration, msg =>
{
bool skipProgressReport = false;
bool isProgressReport = false;
if (IsUpdateMessage(msg))
{
isProgressReport = true;
var now = SystemTime.UtcNow;
compactStatus.LastProgressMessageTime = compactStatus.LastProgressMessageTime ?? DateTime.MinValue;
var timeFromLastUpdate = (now - compactStatus.LastProgressMessageTime.Value);
if (timeFromLastUpdate >= ReportProgressInterval)
{
compactStatus.LastProgressMessageTime = now;
compactStatus.LastProgressMessage = msg;
}
else
{
skipProgressReport = true;
}
}
if (!skipProgressReport)
{
if (!isProgressReport)
{
compactStatus.Messages.Add(msg);
}
DatabasesLandlord.SystemDatabase.Documents.Put(CompactStatus.RavenDatabaseCompactStatusDocumentKey(db), null,
RavenJObject.FromObject(compactStatus), new RavenJObject(), null);
}
}));
compactStatus.State = CompactStatusState.Completed;
compactStatus.Messages.Add("Database compaction completed.");
DatabasesLandlord.SystemDatabase.Documents.Put(CompactStatus.RavenDatabaseCompactStatusDocumentKey(db), null,
RavenJObject.FromObject(compactStatus), new RavenJObject(), null);
}
catch (Exception e)
{
compactStatus.Messages.Add("Unable to compact database " + e.Message);
compactStatus.State = CompactStatusState.Faulted;
DatabasesLandlord.SystemDatabase.Documents.Put(CompactStatus.RavenDatabaseCompactStatusDocumentKey(db), null,
RavenJObject.FromObject(compactStatus), new RavenJObject(), null);
throw;
}
return(GetEmptyMessage());
});
long id;
Database.Tasks.AddTask(task, new TaskBasedOperationState(task), new TaskActions.PendingTaskDescription
{
StartTime = SystemTime.UtcNow,
TaskType = TaskActions.PendingTaskType.CompactDatabase,
Payload = "Compact database " + db,
}, out id);
return(GetMessageWithObject(new
{
OperationId = id
}));
}
