public SnapshotRequestTests()
{
var request = new SnapshotRequest("repos", "snap")
{
IgnoreUnavailable = true,
IncludeGlobalState = true,
WaitForCompletion = true,
Partial = true,
};
var response = this._client.Snapshot(request);
this._status = response.ConnectionStatus;
}
/// <summary>
/// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
/// </summary>
/// <param name="request">The request to send to the server.</param>
/// <param name="method"></param>
/// <param name="cancellationToken"></param>
/// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
/// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
public async Task Snapshot(SnapshotRequest request, Action <SnapshotResponse> method,
CancellationToken cancellationToken, Grpc.Core.Metadata headers = null, DateTime?deadline = null) => await CallEtcdAsync(async (connection) =>
{
using (AsyncServerStreamingCall <SnapshotResponse> snapshotter = connection
._maintenanceClient.Snapshot(request, headers, deadline, cancellationToken))
{
while (await snapshotter.ResponseStream.MoveNext(cancellationToken).ConfigureAwait(false))
{
SnapshotResponse update = snapshotter.ResponseStream.Current;
method(update);
}
}
}).ConfigureAwait(false);
public SnapshotRequestTests()
{
var request = new SnapshotRequest("repos", "snap")
{
IgnoreUnavailable = true,
IncludeGlobalState = true,
WaitForCompletion = true,
Partial = true,
};
var response = this._client.Snapshot(request);
this._status = response.ConnectionStatus;
}
public void TestSnapshotRequest()
{
var request = new SnapshotRequest(new MetricsRecordBuilderTestImpl(), true);
Assert.NotNull(request.Builder);
Assert.Equal(request.FullSnapshot, true);
request = new SnapshotRequest(new MetricsRecordBuilderTestImpl(), false);
Assert.NotNull(request.Builder);
Assert.Equal(request.FullSnapshot, false);
request = new SnapshotRequest(new MetricsRecordBuilderTestImpl());
Assert.NotNull(request.Builder);
Assert.Equal(request.FullSnapshot, false);
}
/// <summary>
/// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
/// </summary>
/// <param name="request"></param>
/// <param name="method"></param>
/// <param name="token"></param>
public async void Snapshot(SnapshotRequest request, Action <SnapshotResponse> method, CancellationToken token, Metadata headers = null)
{
using (AsyncServerStreamingCall <SnapshotResponse> snapshotter = _balancer.GetConnection().maintenanceClient.Snapshot(request, headers))
{
Task snapshotTask = Task.Run(async() =>
{
while (await snapshotter.ResponseStream.MoveNext(token))
{
SnapshotResponse update = snapshotter.ResponseStream.Current;
method(update);
}
});
await snapshotTask;
}
}
/// <summary>
/// Gets metrics from the source.
/// </summary>
/// <param name="collector">Collector that stores the resulting metrics snapshot as records.</param>
/// <param name="all">If true, gets metric values even if they are unchanged.</param>
public void GetMetrics(IMetricsCollector collector, bool all)
{
lock (_lock)
{
var rb = collector.CreateRecord(_recordName)
.SetContext(_sourceContext)
.AddTag("TaskOrContextName", _contextOrTaskName)
.AddTag("EvaluatorId", _evaluatorId)
.AddTag("SourceType", "DefaultSource");
var request = new SnapshotRequest(rb, all);
foreach (var entry in _observers)
{
entry.OnNext(request);
}
foreach (var entry in _tags)
{
rb.Add(entry.Value);
}
}
}
/// <summary>
/// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
/// </summary>
/// <param name="request">The request to send to the server.</param>
/// <param name="methods"></param>
/// <param name="cancellationToken"></param>
/// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
/// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
public async void Snapshot(SnapshotRequest request, Action <SnapshotResponse>[] methods,
CancellationToken cancellationToken, Grpc.Core.Metadata headers = null, DateTime?deadline = null)
{
bool success = false;
int retryCount = 0;
while (!success)
{
try
{
using (AsyncServerStreamingCall <SnapshotResponse> snapshotter = _balancer.GetConnection()
.maintenanceClient.Snapshot(request, headers, deadline, cancellationToken))
{
Task snapshotTask = Task.Run(async() =>
{
while (await snapshotter.ResponseStream.MoveNext(cancellationToken))
{
SnapshotResponse update = snapshotter.ResponseStream.Current;
foreach (Action <SnapshotResponse> method in methods)
{
method(update);
}
}
}, cancellationToken);
await snapshotTask;
}
success = true;
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Unavailable)
{
retryCount++;
if (retryCount >= _balancer._numNodes)
{
throw;
}
}
}
}
/// <summary>
/// Backup existing indexes
/// </summary>
/// <param name="backUpName">The snapshot and backup repository name</param>
/// <param name="path">Check elasticsearch.yml for setting this correctly. Path is declared in path.repo["backuppath"] and is located in path.data folder.</param>
public static void BackUp(string backUpName, string path)
{
var esClient = Manager.EsClient;
var rreq = new CreateRepositoryRequest(backUpName)
{
Repository = new FileSystemRepository(new FileSystemRepositorySettings(path))
};
var rr = esClient.Snapshot.CreateRepository(rreq);
if (rr.ServerError != null)
{
throw new Exception(rr.ServerError.Error.ToString());
}
var sreq = new SnapshotRequest(backUpName, backUpName);
var sr = esClient.Snapshot.Snapshot(sreq);
if (sr.ServerError != null)
{
throw new Exception(sr.ServerError.Error.ToString());
}
}
private void GiveSnapshot(SnapshotRequest request)
{
bool all = request.FullSnapshot;
var recordBuilder = request.Builder;
lock (_lock)
{
var lastStat = Changed ? _intervalStat : _prevStat;
if (all || Changed)
{
recordBuilder.AddCounter(_numSamplesInfo, _runningStat.NumSamples)
.AddGauge(_currentMeanInfo, lastStat.Mean);
if (_showExtendedStats)
{
recordBuilder.AddGauge(_currentMaxInfo, _intervalStat.MinMaxModule.Max)
.AddGauge(_currentMinInfo, _intervalStat.MinMaxModule.Min)
.AddGauge(_currentStdInfo, _intervalStat.Std)
.AddGauge(_runningMaxInfo, _runningStat.MinMaxModule.Max)
.AddGauge(_runningMinInfo, _runningStat.MinMaxModule.Min)
.AddGauge(_runningMeanInfo, _runningStat.Mean)
.AddGauge(_runningStdInfo, _runningStat.Std);
}
if (Changed)
{
if (_runningStat.NumSamples > 0)
{
_prevStat.CopyFrom(_intervalStat);
_intervalStat.Reset();
}
ClearChanged();
}
}
}
}
public void TestGaugeMetrics()
{
const string name = "gaugetest";
const string desc = "guagetestdesc";
IMetricsFactory factory = TangFactory.GetTang().NewInjector().GetInstance <IMetricsFactory>();
var doubleGauge = factory.CreateDoubleGauge(name, desc, 5);
Assert.Equal(name, doubleGauge.Info.Name);
Assert.Equal(desc, doubleGauge.Info.Description);
MetricTestUtils.RecordBuilderForTests recordBuilder = new MetricTestUtils.RecordBuilderForTests();
SnapshotRequest request = new SnapshotRequest(recordBuilder, false);
doubleGauge.OnNext(request);
recordBuilder.Validate(name, 5.0, 1e-10);
recordBuilder.Reset();
doubleGauge.Increment(2.2);
doubleGauge.OnNext(request);
recordBuilder.Validate(name, 7.2, 1e-10);
recordBuilder.Reset();
doubleGauge.Decrement(1);
doubleGauge.OnNext(request);
recordBuilder.Validate(name, 6.2, 1e-10);
recordBuilder.Reset();
doubleGauge.OnNext(request);
Assert.False(recordBuilder.DoubleKeyPresent(name), "Metric is not supposed to be recorded.");
request = new SnapshotRequest(recordBuilder, true);
doubleGauge.OnNext(request);
recordBuilder.Validate(name, 6.2, 1e-10);
recordBuilder.Reset();
request = new SnapshotRequest(recordBuilder, false);
var longGauge = factory.CreateLongGauge(name, desc, 5);
Assert.Equal(name, longGauge.Info.Name);
Assert.Equal(desc, longGauge.Info.Description);
longGauge.OnNext(request);
recordBuilder.Validate(name, (long)5);
recordBuilder.Reset();
longGauge.Increment(2);
longGauge.OnNext(request);
recordBuilder.Validate(name, (long)7);
recordBuilder.Reset();
longGauge.Decrement(1);
longGauge.OnNext(request);
recordBuilder.Validate(name, (long)6);
recordBuilder.Reset();
longGauge.OnNext(request);
Assert.False(recordBuilder.LongKeyPresent(name), "Metric is not supposed to be recorded.");
request = new SnapshotRequest(recordBuilder, true);
longGauge.OnNext(request);
recordBuilder.Validate(name, (long)6);
recordBuilder.Reset();
}
public void TestStatMetrics()
{
const string name = "stattest";
const string desc = "stattestdesc";
const string valueName = "statValName";
const double delta = 1e-10;
IMetricsFactory factory = TangFactory.GetTang().NewInjector().GetInstance <IMetricsFactory>();
double[] array1 = new double[3];
double[] array2 = new double[3];
Random randGen = new Random();
array1 = array1.Select(x => randGen.NextDouble()).ToArray();
array2 = array2.Select(x => randGen.NextDouble()).ToArray();
var stat = factory.CreateStatMetric(name, desc, valueName);
MetricTestUtils.RecordBuilderForTests recordBuilder = new MetricTestUtils.RecordBuilderForTests();
var request = new SnapshotRequest(recordBuilder, false);
foreach (var entry in array1)
{
stat.Sample(entry);
}
double expectedMean = array1.Sum() / 3;
double expectedStd = Math.Sqrt(array1.Select(x => Math.Pow(x - expectedMean, 2)).Sum() / 2);
stat.OnNext(request);
recordBuilder.Validate(name + "-Num", (long)3);
recordBuilder.Validate(name + "-RunningAvg", expectedMean, delta);
recordBuilder.Validate(name + "-RunningStdev", expectedStd, delta);
recordBuilder.Validate(name + "-IntervalAvg", expectedMean, delta);
recordBuilder.Validate(name + "-IntervalStdev", expectedStd, delta);
recordBuilder.Validate(name + "-RunningMin", array1.Min(), delta);
recordBuilder.Validate(name + "-IntervalMin", array1.Min(), delta);
recordBuilder.Validate(name + "-RunningMax", array1.Max(), delta);
recordBuilder.Validate(name + "-IntervalMax", array1.Max(), delta);
recordBuilder.Reset();
foreach (var entry in array2)
{
stat.Sample(entry);
}
double expectedIntervalMean = array2.Sum() / 3;
double expectedIntervalStd = Math.Sqrt(array2.Select(x => Math.Pow(x - expectedIntervalMean, 2)).Sum() / 2);
double expectedIntervalMin = array2.Min();
double expectedIntervalMax = array2.Max();
double expectedRunningMean = (array1.Sum() + array2.Sum()) / 6;
double expectedRunningStd =
Math.Sqrt((array1.Select(x => Math.Pow(x - expectedRunningMean, 2)).Sum() +
array2.Select(x => Math.Pow(x - expectedRunningMean, 2)).Sum()) / 5);
double expectedRunningMin = Math.Min(array1.Min(), array2.Min());
double expectedRunningMax = Math.Max(array1.Max(), array2.Max());
stat.OnNext(request);
recordBuilder.Validate(name + "-Num", (long)6);
recordBuilder.Validate(name + "-RunningAvg", expectedRunningMean, delta);
recordBuilder.Validate(name + "-RunningStdev", expectedRunningStd, delta);
recordBuilder.Validate(name + "-IntervalAvg", expectedIntervalMean, delta);
recordBuilder.Validate(name + "-IntervalStdev", expectedIntervalStd, delta);
recordBuilder.Validate(name + "-RunningMin", expectedRunningMin, delta);
recordBuilder.Validate(name + "-IntervalMin", expectedIntervalMin, delta);
recordBuilder.Validate(name + "-RunningMax", expectedRunningMax, delta);
recordBuilder.Validate(name + "-IntervalMax", expectedIntervalMax, delta);
recordBuilder.Reset();
stat.OnNext(request);
Assert.False(recordBuilder.LongKeyPresent(name + "-Num"), "Metric is not supposed to be recorded.");
request = new SnapshotRequest(recordBuilder, true);
stat.OnNext(request);
Assert.True(recordBuilder.LongKeyPresent(name + "-Num"), "Metric is supposed to be recorded.");
}
/// <summary>
/// Simply calls the OnNext() of registered observer.
/// </summary>
/// <param name="value">Snapshot request instance</param>
public void OnNext(SnapshotRequest value)
{
_observer.OnNext(value);
}
