private List <CounterStorageReplicationDestination> GetReplicationDestinations()
{
CounterStorageReplicationDocument replicationData;
using (var reader = storage.CreateReader())
replicationData = reader.GetReplicationData();
return((replicationData != null) ? replicationData.Destinations : null);
}
private List <CounterReplicationDestination> GetReplicationDestinations()
{
CountersReplicationDocument replicationData;
using (var reader = storage.CreateReader())
replicationData = reader.GetReplicationData();
return(replicationData?.Destinations);
}
public CountersReplicationTopologyRootNode Discover()
{
var root = new CountersReplicationTopologyRootNode(counterStorage.CounterStorageUrl, counterStorage.ServerId);
if (ttl <= 0)
{
return(root);
}
CountersReplicationDocument replicationData;
IEnumerable <CounterStorage.ReplicationSourceInfo> serverSources;
using (var reader = counterStorage.CreateReader())
{
replicationData = reader.GetReplicationData();
serverSources = reader.GetReplicationSources().ToList();
}
if (@from.Contains(counterStorage.CounterStorageUrl) == false)
{
@from.Add(counterStorage.CounterStorageUrl);
}
if (replicationData != null)
{
root.Destinations = HandleDestinations(replicationData.Destinations);
}
root.Sources = HandleSources(serverSources, root);
return(root);
}
public HttpResponseMessage GetCounterOverallTotal(string groupName, string counterName)
{
var verificationResult = VerifyGroupAndCounterName(groupName, counterName);
if (verificationResult != null)
{
return(verificationResult);
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
using (var reader = CounterStorage.CreateReader())
{
try
{
long?total;
if (!reader.TryGetCounterTotal(groupName, counterName, out total))
{
return(GetMessageWithObject(new CounterTotal {
IsExists = false
}, HttpStatusCode.NotFound));
}
Debug.Assert(total.HasValue);
return(GetMessageWithObject(new CounterTotal {
IsExists = true, Total = total.Value
}));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
}
private BackupStatus GetBackupStatus()
{
using (var reader = storage.CreateReader())
{
return(reader.GetBackupStatus());
}
}
public HttpResponseMessage GetCounterOverallTotal(string groupName, string counterName)
{
var verificationResult = VerifyGroupAndCounterName(groupName, counterName);
if (verificationResult != null)
{
return(verificationResult);
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
using (var reader = CounterStorage.CreateReader())
{
try
{
var overallTotal = reader.GetCounterTotal(groupName, counterName);
return(Request.CreateResponse(HttpStatusCode.OK, overallTotal));
}
catch (InvalidDataException e)
{
if (e.Data.Contains("DoesntExist"))
{
return(Request.CreateResponse(HttpStatusCode.NotFound, "Counter with specified group and name wasn't found"));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
}
public HttpResponseMessage GetLastEtag(Guid serverId)
{
using (var reader = CounterStorage.CreateReader())
{
var lastEtag = reader.GetLastEtagFor(serverId);
return(Request.CreateResponse(HttpStatusCode.OK, lastEtag));
}
}
public HttpResponseMessage GetCounterGroups(int skip, int take)
{
using (var reader = CounterStorage.CreateReader())
{
CounterStorage.MetricsCounters.ClientRequests.Mark();
return(Request.CreateResponse(HttpStatusCode.OK, reader.GetCounterGroups(skip, take).ToList()));
}
}
public HttpResponseMessage GetCounterStatesSinceEtag(long etag, int skip, int take)
{
List <CounterState> deltas;
using (var reader = CounterStorage.CreateReader())
deltas = reader.GetCountersSinceEtag(etag + 1, skip, take).ToList();
return(GetMessageWithObject(deltas));
}
public HttpResponseMessage ReplicationsGet()
{
using (var reader = CounterStorage.CreateReader())
{
var replicationData = reader.GetReplicationData();
if (replicationData == null || replicationData.Destinations.Count == 0)
{
return(GetEmptyMessage(HttpStatusCode.NotFound));
}
return(GetMessageWithObject(replicationData));
}
}
public HttpResponseMessage GetCounter(string groupName, string counterName)
{
var verificationResult = VerifyGroupAndCounterName(groupName, counterName);
if (verificationResult != null)
{
return(verificationResult);
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
using (var reader = CounterStorage.CreateReader())
{
var result = reader.GetCounter(groupName, counterName);
return(GetMessageWithObject(result));
}
}
public void Incremental_backup_and_restore_should_work()
{
var backupOperation = NewBackupOperation(true);
StoreCounterChange(5, storage);
backupOperation.Execute();
Thread.Sleep(100);
StoreCounterChange(-2, storage);
backupOperation.Execute();
Thread.Sleep(100);
StoreCounterChange(3, storage);
backupOperation.Execute();
var restoreOperation = NewRestoreOperation();
restoreOperation.Execute();
var restoreConfig = new RavenConfiguration
{
RunInMemory = false
};
restoreConfig.Counter.DataDirectory = RestoreToDirectory;
using (var restoredStorage = new CounterStorage("http://localhost:8081", "RestoredCounter", restoreConfig))
{
using (var reader = restoredStorage.CreateReader())
{
long?total;
Assert.True(reader.TryGetCounterTotal("Bar", "Foo", out total));
Assert.NotNull(total);
Assert.Equal(6, total.Value);
/*var counter = reader.GetCounterValuesByPrefix("Bar", "Foo");
* var counterValues = counter.CounterValues.ToArray();
*
* Assert.Equal(8, counterValues[0].Value);
* Assert.True(counterValues[0].IsPositive());
* Assert.Equal(2, counterValues[1].Value);
* Assert.False(counterValues[1].IsPositive());*/
}
}
}
public HttpResponseMessage GetCounterSummariesByGroup(int skip, int take, string group)
{
if (skip < 0)
{
return(GetMessageWithString("Skip must be non-negative number", HttpStatusCode.BadRequest));
}
if (take <= 0)
{
return(GetMessageWithString("Take must be non-negative number", HttpStatusCode.BadRequest));
}
CounterStorage.MetricsCounters.ClientRequests.Mark();
using (var reader = CounterStorage.CreateReader())
{
group = group ?? string.Empty;
var counters = reader.GetCounterSummariesByGroup(group, skip, take);
return(GetMessageWithObject(counters));
}
}
public HttpResponseMessage StreamCounterGroups()
{
int skip;
int take;
HttpResponseMessage errorResponse;
if (!GetAndValidateSkipAndTake(out skip, out take, out errorResponse))
{
return(errorResponse);
}
Func <Stream, IOutputWriter> getWriter;
if (!GetRelevantWriterFactory(out getWriter, out errorResponse))
{
return(errorResponse);
}
var response = GetEmptyMessage();
CounterStorage.MetricsCounters.ClientRequests.Mark();
var reader = CounterStorage.CreateReader();
var groups = reader.GetCounterGroups(skip, take); //since its enumerable, this is ok
response.Content =
new StreamContent(CountersLandlord,
getWriter, groups.Select(RavenJObject.FromObject),
mediaType => response.Content.Headers.ContentType = new MediaTypeHeaderValue(mediaType)
{
CharSet = "utf-8"
},
reader);
if (IsCsvDownloadRequest(InnerRequest))
{
response.Content.Headers.Add("Content-Disposition", "attachment; filename=export.csv");
}
return(response);
}
private HttpResponseMessage GetSummariesForAllGroupsStreamResponse(int skip, int take, HttpResponseMessage response, Func <Stream, IOutputWriter> getWriter)
{
CounterStorage.MetricsCounters.ClientRequests.Mark();
var reader = CounterStorage.CreateReader();
var groups = reader.GetCounterGroups(0, int.MaxValue); //since it is enumerable, this is not taking up alot of memory
var counters = groups.SelectMany(@group => reader.GetCounterSummariesByPrefix(@group.Name, null, skip, take));
response.Content =
new StreamContent(CountersLandlord,
getWriter, counters.Select(RavenJObject.FromObject),
mediaType => response.Content.Headers.ContentType = new MediaTypeHeaderValue(mediaType)
{
CharSet = "utf-8"
},
reader);
if (IsCsvDownloadRequest(InnerRequest))
{
response.Content.Headers.Add("Content-Disposition", "attachment; filename=export.csv");
}
return(response);
}
public HttpResponseMessage GetCountersByPrefix(string groupName, int skip, int take, string counterNamePrefix = null)
{
if (string.IsNullOrWhiteSpace(groupName))
{
return(GetMessageWithObject(new
{
Message = $"{nameof(groupName)} is a required parameter, thus it must not be null or empty"
}, HttpStatusCode.BadRequest));
}
HttpResponseMessage messageWithObject;
if (!ValidateSkipAndTake(skip, take, out messageWithObject))
{
return(messageWithObject);
}
using (var reader = CounterStorage.CreateReader())
{
var counterSummaries = reader.GetCounterSummariesByPrefix(groupName, counterNamePrefix, skip, take).ToList();
return(GetMessageWithObject(counterSummaries));
}
}
private HttpResponseMessage GetSummariesPerGroupByPrefixStreamResponse(string @group, string counterNamePrefix, int skip, int take, HttpResponseMessage response, Func <Stream, IOutputWriter> getWriter)
{
CounterStorage.MetricsCounters.ClientRequests.Mark();
var reader = CounterStorage.CreateReader();
@group = @group ?? string.Empty;
var counters = reader.GetCounterSummariesByPrefix(@group, counterNamePrefix, skip, take);
response.Content =
new StreamContent(CountersLandlord,
getWriter, counters.Select(RavenJObject.FromObject),
mediaType => response.Content.Headers.ContentType = new MediaTypeHeaderValue(mediaType)
{
CharSet = "utf-8"
},
reader);
if (IsCsvDownloadRequest(InnerRequest))
{
response.Content.Headers.Add("Content-Disposition", "attachment; filename=export.csv");
}
return(response);
}
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());
}
}
