private void SetBackupStatus(BackupStatus backupStatus)
{
using (var writer = storage.CreateWriter())
{
writer.SaveBackupStatus(backupStatus);
}
}
public HttpResponseMessage Delete(string groupName, string counterName)
{
var verificationResult = VerifyGroupAndCounterName(groupName, counterName);
if (verificationResult != null)
{
return(verificationResult);
}
using (var writer = CounterStorage.CreateWriter())
{
writer.Delete(groupName, counterName);
writer.Commit();
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
CounterStorage.MetricsCounters.Deletes.Mark();
CounterStorage.Publisher.RaiseNotification(new ChangeNotification
{
GroupName = groupName,
CounterName = counterName,
Action = CounterChangeAction.Delete,
Delta = 0,
Total = 0
});
return(GetEmptyMessage(HttpStatusCode.NoContent));
}
private void StoreCounterChange(long change, CounterStorage counterStorage)
{
using (var writer = counterStorage.CreateWriter())
{
writer.Store("Bar", "Foo", change);
writer.Commit();
}
}
private static void SetupCounters(CounterStorage counterStorage)
{
using (var writer = counterStorage.CreateWriter())
{
writer.Store("ga", "ca", 0);
writer.Store("ga", "cb", 1);
writer.Store("ga", "cc", 2);
writer.Store("gb", "cb", 2);
writer.Store("gc", "cc", 3);
writer.Commit();
}
}
public async Task <HttpResponseMessage> ReplicationsSave()
{
var newReplicationDocument = await ReadJsonObjectAsync <CountersReplicationDocument>().ConfigureAwait(false);
using (var writer = CounterStorage.CreateWriter())
{
writer.UpdateReplications(newReplicationDocument);
writer.Commit();
return(GetEmptyMessage());
}
}
public HttpResponseMessage PurgeTombstones()
{
CounterStorage.MetricsCounters.ClientRequests.Mark();
while (true)
{
using (var writer = CounterStorage.CreateWriter())
{
if (writer.PurgeOutdatedTombstones() == false)
{
break;
}
writer.Commit();
}
}
return(GetEmptyMessage());
}
public HttpResponseMessage DeleteByGroup(string groupName)
{
groupName = groupName ?? string.Empty;
var deletedCount = 0;
while (true)
{
var changeNotifications = new List <ChangeNotification>();
using (var writer = CounterStorage.CreateWriter())
{
var countersDetails = writer.GetCountersDetails(groupName).Take(1024).ToList();
if (countersDetails.Count == 0)
{
break;
}
foreach (var c in countersDetails)
{
writer.DeleteCounterInternal(c.Group, c.Name);
changeNotifications.Add(new ChangeNotification
{
GroupName = c.Group,
CounterName = c.Name,
Action = CounterChangeAction.Delete,
Delta = 0,
Total = 0
});
}
writer.Commit();
deletedCount += changeNotifications.Count;
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
changeNotifications.ForEach(change =>
{
CounterStorage.Publisher.RaiseNotification(change);
CounterStorage.MetricsCounters.Deletes.Mark();
});
}
return(GetMessageWithObject(deletedCount));
}
public HttpResponseMessage Change(string groupName, string counterName, long delta)
{
var verificationResult = VerifyGroupAndCounterName(groupName, counterName);
if (verificationResult != null)
{
return(verificationResult);
}
CounterChangeAction counterChangeAction;
long?total = 0;
using (var writer = CounterStorage.CreateWriter())
{
counterChangeAction = writer.Store(groupName, counterName, delta);
if (delta == 0 && counterChangeAction != CounterChangeAction.Add)
{
return(GetEmptyMessage());
}
writer.Commit();
if (!writer.TryGetCounterTotal(groupName, counterName, out total))
{
return(GetMessageWithObject(new
{
Message = $"Could not find a counter with groupName = {groupName}, counterName = {counterName}"
}, HttpStatusCode.NotFound));
}
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
CounterStorage.Publisher.RaiseNotification(new ChangeNotification
{
GroupName = groupName,
CounterName = counterName,
Action = counterChangeAction,
Delta = delta,
Total = total.Value
});
return(GetEmptyMessage());
}
public HttpResponseMessage Reset(string groupName, string counterName)
{
var verificationResult = VerifyGroupAndCounterName(groupName, counterName);
if (verificationResult != null)
{
return(verificationResult);
}
long difference = 0;
using (var writer = CounterStorage.CreateWriter())
{
difference = writer.Reset(groupName, counterName);
if (difference != 0)
{
writer.Commit();
}
}
if (difference != 0)
{
CounterStorage.MetricsCounters.ClientRequests.Mark();
CounterStorage.MetricsCounters.Resets.Mark();
CounterStorage.Publisher.RaiseNotification(new ChangeNotification
{
GroupName = groupName,
CounterName = counterName,
Action = difference >= 0 ? CounterChangeAction.Increment : CounterChangeAction.Decrement,
Delta = difference,
Total = 0
});
}
return(GetEmptyMessage());
}
public HttpResponseMessage Change(string groupName, string counterName, long delta)
{
var verificationResult = VerifyGroupAndCounterName(groupName, counterName);
if (verificationResult != null)
{
return(verificationResult);
}
CounterChangeAction counterChangeAction;
long total = 0;
using (var writer = CounterStorage.CreateWriter())
{
counterChangeAction = writer.Store(groupName, counterName, delta);
if (delta == 0 && counterChangeAction != CounterChangeAction.Add)
{
return(GetEmptyMessage());
}
writer.Commit();
total = writer.GetCounterTotal(groupName, counterName);
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
CounterStorage.Publisher.RaiseNotification(new ChangeNotification
{
GroupName = groupName,
CounterName = counterName,
Action = counterChangeAction,
Delta = delta,
Total = total
});
return(GetEmptyMessage());
}
public async Task <HttpResponseMessage> Post()
{
/*Read Current Counter Value for CounterStorageName - Need ReaderWriter Lock
* If values are ABS larger
* Write delta
* Store last ETag for servers we've successfully rpelicated to
*/
ReplicationMessage replicationMessage;
CounterStorage.MetricsCounters.IncomingReplications.Mark();
try
{
replicationMessage = await ReadJsonObjectAsync <ReplicationMessage>().ConfigureAwait(false);
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, e.Message));
}
long lastEtag = 0;
var wroteCounter = false;
using (var writer = CounterStorage.CreateWriter())
{
var counterChangeNotifications = new List <ChangeNotification>();
foreach (var counter in replicationMessage.Counters)
{
lastEtag = Math.Max(counter.Etag, lastEtag);
var singleCounterValue = writer.GetSingleCounterValue(counter.GroupName, counter.CounterName, counter.ServerId, counter.Sign);
var currentCounterValue = singleCounterValue.Value;
//if current counter exists and current value is less than received value
if ((currentCounterValue != -1 && counter.Value < currentCounterValue) ||
(counter.Value == currentCounterValue && (singleCounterValue.DoesCounterExist || writer.IsTombstone(counter.ServerId))))
{
continue;
}
wroteCounter = true;
var counterChangeAction = writer.Store(counter.GroupName, counter.CounterName, counter.ServerId, counter.Sign, counter.Value);
counterChangeNotifications.Add(new ChangeNotification
{
GroupName = counter.GroupName,
CounterName = counter.CounterName,
Delta = counter.Value - currentCounterValue,
Action = counterChangeAction
});
}
var serverId = replicationMessage.ServerId;
if (wroteCounter || writer.GetLastEtagFor(serverId) < lastEtag)
{
writer.RecordSourceNameFor(serverId, replicationMessage.SendingServerName);
writer.RecordLastEtagFor(serverId, lastEtag);
writer.Commit();
using (var reader = CounterStorage.CreateReader())
{
counterChangeNotifications.ForEach(change =>
{
change.Total = reader.GetCounterTotal(change.GroupName, change.CounterName);
CounterStorage.Publisher.RaiseNotification(change);
});
}
}
return(GetEmptyMessage());
}
}
public async Task <HttpResponseMessage> CountersBatch()
{
if (string.IsNullOrEmpty(GetQueryStringValue("no-op")) == false)
{
// this is a no-op request which is there just to force the client HTTP layer to handle the authentication
// only used for legacy clients
return(GetEmptyMessage());
}
if ("generate-single-use-auth-token".Equals(GetQueryStringValue("op"), StringComparison.InvariantCultureIgnoreCase))
{
// using windows auth with anonymous access = none sometimes generate a 401 even though we made two requests
// instead of relying on windows auth, which require request buffering, we generate a one time token and return it.
// we KNOW that the user have access to this db for writing, since they got here, so there is no issue in generating
// a single use token for them.
var authorizer = (MixedModeRequestAuthorizer)Configuration.Properties[typeof(MixedModeRequestAuthorizer)];
var token = authorizer.GenerateSingleUseAuthToken(CountersName, User);
return(GetMessageWithObject(new
{
Token = token
}));
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
if (HttpContext.Current != null)
{
HttpContext.Current.Server.ScriptTimeout = 60 * 60 * 6; // six hours should do it, I think.
}
var sp = Stopwatch.StartNew();
var status = new BatchStatus();
var timeoutTokenSource = new CancellationTokenSource();
var counterChanges = 0;
var operationId = ExtractOperationId();
var inputStream = await InnerRequest.Content.ReadAsStreamAsync().ConfigureAwait(false);
var task = Task.Factory.StartNew(() =>
{
var timeout = timeoutTokenSource.TimeoutAfter(SystemConfiguration.Counter.BatchTimeout);
var changeBatches = YieldChangeBatches(inputStream, timeout, countOfChanges => counterChanges += countOfChanges);
try
{
foreach (var changeBatch in changeBatches)
{
using (var writer = CounterStorage.CreateWriter())
{
CounterStorage.Publisher.RaiseNotification(new BulkOperationNotification
{
Type = BatchType.Started,
OperationId = operationId
});
foreach (var change in changeBatch)
{
var verificationResult = VerifyGroupAndCounterName(change.Group, change.Name);
if (verificationResult != null)
{
throw new ArgumentException("Missing group or counter name");
}
writer.Store(change.Group, change.Name, change.Delta);
}
writer.Commit();
CounterStorage.Publisher.RaiseNotification(new BulkOperationNotification
{
Type = BatchType.Ended,
OperationId = operationId
});
}
}
status.MarkCompleted(string.Format("Counters: {0}", counterChanges));
}
catch (OperationCanceledException)
{
// happens on timeout
CounterStorage.Publisher.RaiseNotification(new BulkOperationNotification
{
Type = BatchType.Error,
OperationId = operationId,
Message = "Operation cancelled, likely because of a batch timeout"
});
status.MarkCanceled("Operation cancelled, likely because of a batch timeout");
throw;
}
catch (Exception e)
{
var errorMessage = e.SimplifyException().Message;
CounterStorage.Publisher.RaiseNotification(new BulkOperationNotification
{
Type = BatchType.Error,
OperationId = operationId,
Message = errorMessage
});
status.MarkFaulted(errorMessage);
throw;
}
finally
{
status.Counters = counterChanges;
}
}, timeoutTokenSource.Token);
long id;
DatabasesLandlord.SystemDatabase.Tasks.AddTask(task, status, new TaskActions.PendingTaskDescription
{
StartTime = SystemTime.UtcNow,
TaskType = TaskActions.PendingTaskType.CounterBatchOperation,
Description = operationId.ToString()
}, out id, timeoutTokenSource);
AddRequestTraceInfo(log =>
log.AppendFormat("\tCounters batch operation received {0:#,#;;0} changes in {1}, long running task Id : {2}", counterChanges, sp.Elapsed, id));
task.Wait(timeoutTokenSource.Token);
return(GetMessageWithObject(new
{
OperationId = id
}, HttpStatusCode.Accepted));
}
