public void if_task_has_already_started_just_return_the_started_task()
{
using (var scheduler = new DefaultTaskScheduler(false))
{
var data = 0;
var completionSource = new TaskCompletionSource <bool>();
scheduler.Interval(
TimeSpan.FromMilliseconds(40),
TaskCreationOptions.LongRunning,
() =>
{
data++;
completionSource.SetResult(true);
});
scheduler.Interval(
TimeSpan.FromMilliseconds(20),
TaskCreationOptions.LongRunning,
() =>
{
data++;
completionSource.SetResult(true);
});
completionSource.Task.Wait();
scheduler.Stop();
data.Should().Be(1);
}
}
public void executes_scheduled_action_muliple_times()
{
using (var scheduler = new DefaultTaskScheduler())
{
var data = 0;
var completionSource = new TaskCompletionSource <bool>();
scheduler.Interval(
TimeSpan.FromMilliseconds(20),
TaskCreationOptions.LongRunning,
() =>
{
data++;
completionSource.SetResult(true);
});
completionSource.Task.Wait();
data.Should().Be(1);
completionSource = new TaskCompletionSource <bool>();
completionSource.Task.Wait();
data.Should().BeGreaterOrEqualTo(2);
scheduler.Stop();
}
}
public static void ScheduleMetricReporting(this IServiceProvider provider,
CancellationTokenSource cancellationTokenSource)
{
var application = new Application(provider);
var scheduler = new DefaultTaskScheduler();
Task.Factory
.StartNew(() =>
{
scheduler.Interval(TimeSpan.FromMilliseconds(300),
TaskCreationOptions.None,
() =>
{
// Run Metrics
},
cancellationTokenSource.Token);
});
Task.Factory
.StartNew(() =>
{
application.Reporter.RunReports(application.Metrics,
cancellationTokenSource.Token);
});
}
public void can_provide_own_token_with_is_then_linked()
{
Task scheduledTask = null;
var token = new CancellationTokenSource();
token.CancelAfter(200);
Action action = () =>
{
using (var scheduler = new DefaultTaskScheduler())
{
scheduledTask = scheduler.Interval(
TimeSpan.FromMilliseconds(40),
TaskCreationOptions.LongRunning,
async() =>
{
// ReSharper disable MethodSupportsCancellation
await Task.Delay(1000);
// ReSharper restore MethodSupportsCancellation
},
token.Token);
// ReSharper disable MethodSupportsCancellation
scheduledTask.Wait();
// ReSharper restore MethodSupportsCancellation
}
};
action.ShouldNotThrow <TaskCanceledException>();
scheduledTask.Status.Should().Be(TaskStatus.RanToCompletion);
}
private static void SetupResetMetrics()
{
var resetMetricScheduler = new DefaultTaskScheduler();
resetMetricScheduler.Interval(TimeSpan.FromSeconds(10), TaskCreationOptions.None, () =>
{
// Reset the counter to zero
_metrics.Advanced.Counter(SampleMetricRegistry.SentEmailsCounter).Reset();
});
}
private static void RunSampleRequests(CancellationToken token)
{
var scheduler = new DefaultTaskScheduler();
var httpClient = new HttpClient
{
BaseAddress = ApiBaseAddress
};
Task.Run(
() => scheduler.Interval(
TimeSpan.FromMilliseconds(200),
TaskCreationOptions.None,
async() =>
{
var satisfied = httpClient.GetAsync("api/apdexsatisfied", token);
var tolerating = httpClient.GetAsync("api/apdextolerating", token);
var frustrating = httpClient.GetAsync("api/apdexfrustrating", token);
await Task.WhenAll(satisfied, tolerating, frustrating);
},
token),
token);
Task.Run(
() => scheduler.Interval(
TimeSpan.FromSeconds(1),
TaskCreationOptions.None,
async() =>
{
var satisfied = httpClient.GetAsync("api/error", token);
var internalException = httpClient.GetAsync("api/error/500", token);
await Task.WhenAll(satisfied, internalException);
},
token),
token);
}
public void throws_if_poll_interval_is_zero()
{
Action action = () =>
{
using (var scheduler = new DefaultTaskScheduler())
{
var completionSource = new TaskCompletionSource <bool>();
scheduler.Interval(TimeSpan.Zero, TaskCreationOptions.LongRunning, () => { completionSource.SetResult(true); });
completionSource.Task.Wait();
scheduler.Stop();
}
};
action.ShouldThrow <ArgumentOutOfRangeException>();
}
private void RunReservoir(IReservoir reservoir)
{
var scheduler = new DefaultTaskScheduler();
scheduler.Interval(
TimeSpan.FromMilliseconds(20),
TaskCreationOptions.None,
() =>
{
reservoir.GetSnapshot();
reservoir.Reset();
});
SimpleBenchmarkRunner.Run(
() => { reservoir.Update(_fixture.Rnd.Next(0, 1000), _fixture.RandomUserValue); });
scheduler.Dispose();
}
public void can_execute_scheduled_action()
{
using (var scheduler = new DefaultTaskScheduler())
{
var data = 0;
var completionSource = new TaskCompletionSource <bool>();
scheduler.Interval(TimeSpan.FromMilliseconds(20), () =>
{
data++;
completionSource.SetResult(true);
});
completionSource.Task.Wait();
scheduler.Stop();
data.Should().Be(1);
}
}
public void executes_scheduled_action_with_token()
{
using (var scheduler = new DefaultTaskScheduler())
{
var data = 0;
var token = new CancellationTokenSource();
var completionSource = new TaskCompletionSource <bool>();
scheduler.Interval(TimeSpan.FromMilliseconds(20), () =>
{
data++;
completionSource.SetResult(true);
}, token.Token);
completionSource.Task.Wait(token.Token);
scheduler.Stop();
data.Should().Be(1);
}
}
public void gracefully_cancel_task_if_the_action_throws()
{
Task scheduledTask = null;
Action action = () =>
{
using (var scheduler = new DefaultTaskScheduler())
{
scheduledTask = scheduler.Interval(
TimeSpan.FromMilliseconds(40),
TaskCreationOptions.LongRunning,
() => throw new InvalidOperationException());
scheduledTask.Wait();
}
};
action.ShouldNotThrow();
scheduledTask.Status.Should().Be(TaskStatus.RanToCompletion);
}
private static void RunRequestsToSample(CancellationToken token)
{
var scheduler = new DefaultTaskScheduler();
var httpClient = new HttpClient
{
BaseAddress = ApiBaseAddress
};
Task.Run(() => scheduler.Interval(
TimeSpan.FromMilliseconds(100),
TaskCreationOptions.None,
async() =>
{
var uniform = httpClient.GetStringAsync("api/reservoirs/uniform");
var exponentiallyDecaying = httpClient.GetStringAsync("api/reservoirs/exponentially-decaying");
var slidingWindow = httpClient.GetStringAsync("api/reservoirs/sliding-window");
var hdr = httpClient.GetStringAsync("api/reservoirs/high-dynamic-range");
await Task.WhenAll(uniform, exponentiallyDecaying, slidingWindow, hdr);
},
token), token);
}
private static void RunSampleRequests(CancellationToken token)
{
var scheduler = new DefaultTaskScheduler();
var httpClient = new HttpClient
{
BaseAddress = new Uri("http://localhost:50202")
};
Task.Run(
() => scheduler.Interval(
TimeSpan.FromMilliseconds(200),
TaskCreationOptions.None,
async() =>
{
var satisfied = httpClient.GetAsync("api/values", token);
var bad = httpClient.GetAsync("api/bad", token);
var unauth = httpClient.GetAsync("api/unauth", token);
var error = httpClient.GetAsync("api/error", token);
await Task.WhenAll(satisfied, bad, unauth);
},
token),
token);
}
private static void SetupSampleScheduler(Application application)
{
var scheduler = new DefaultTaskScheduler();
scheduler.Interval(TimeSpan.FromMilliseconds(300), TaskCreationOptions.None, () => { application.CounterSamples.RunSamples(); });
}
public static void Main()
{
var cpuUsage = new CpuUsage();
cpuUsage.Start();
IServiceCollection serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
ConfigureMetrics(serviceCollection);
var process = Process.GetCurrentProcess();
var provider = serviceCollection.BuildServiceProvider();
var application = new Application(provider);
var scheduler = new DefaultTaskScheduler();
var simpleMetrics = new SampleMetrics(application.Metrics);
var setCounterSample = new SetCounterSample(application.Metrics);
var setMeterSample = new SetMeterSample(application.Metrics);
var userValueHistogramSample = new UserValueHistogramSample(application.Metrics);
var userValueTimerSample = new UserValueTimerSample(application.Metrics);
//var rnd = new Random();
//foreach (var index in Enumerable.Range(0, 30))
//{
// using (application.Metrics.Track(AppMetricsRegistry.ApdexScores.AppApdex))
// {
// if (index % 4 == 0)
// {
// Thread.Sleep(rnd.Next(2100, 2200));
// }
// else if (index % 2 == 0)
// {
// Thread.Sleep(rnd.Next(600, 700));
// }
// else
// {
// Thread.Sleep(rnd.Next(0, 300));
// }
// }
//}
var cancellationTokenSource = new CancellationTokenSource();
var task = scheduler.Interval(
TimeSpan.FromMilliseconds(300), () =>
{
using (application.Metrics.Track(AppMetricsRegistry.ApdexScores.AppApdex))
{
setCounterSample.RunSomeRequests();
setMeterSample.RunSomeRequests();
userValueHistogramSample.RunSomeRequests();
//userValueTimerSample.RunSomeRequests(); //TODO: AH - why's this taking so long?
simpleMetrics.RunSomeRequests();
}
application.Metrics.Gauge(AppMetricsRegistry.Gauges.Errors, () => 1);
application.Metrics.Gauge(AppMetricsRegistry.Gauges.PercentGauge, () => 1);
application.Metrics.Gauge(AppMetricsRegistry.Gauges.ApmGauge, () => 1);
application.Metrics.Gauge(AppMetricsRegistry.Gauges.ParenthesisGauge, () => 1);
application.Metrics.Gauge(AppMetricsRegistry.Gauges.GaugeWithNoValue, () => double.NaN);
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.CpuUsageTotal, () =>
{
cpuUsage.CallCpu();
return(cpuUsage.CpuUsageTotal);
});
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.ProcessPagedMemorySizeGauge, () => process.PagedMemorySize64);
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.ProcessPeekPagedMemorySizeGauge, () => process.PeakPagedMemorySize64);
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.ProcessPeekVirtualMemorySizeGauge,
() => process.PeakVirtualMemorySize64);
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.ProcessPeekWorkingSetSizeGauge, () => process.WorkingSet64);
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.ProcessPrivateMemorySizeGauge, () => process.PrivateMemorySize64);
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.ProcessVirtualMemorySizeGauge, () => process.VirtualMemorySize64);
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.SystemNonPagedMemoryGauge, () => process.NonpagedSystemMemorySize64);
application.Metrics.Gauge(AppMetricsRegistry.ProcessMetrics.SystemPagedMemorySizeGauge, () => process.PagedSystemMemorySize64);
}, cancellationTokenSource.Token);
application.Reporter.RunReportsAsync(application.Metrics, cancellationTokenSource.Token);
Console.WriteLine("Setup Complete, waiting for report run...");
Console.ReadKey();
}
public static void Run(CancellationToken token)
{
var randomBufferGenerator = new RandomBufferGenerator(50000);
var scheduler = new DefaultTaskScheduler();
var httpClient = new HttpClient
{
BaseAddress = ApiBaseAddress
};
Task.Run(
() => scheduler.Interval(
TimeSpan.FromSeconds(1),
TaskCreationOptions.None,
async() =>
{
var satisfied = httpClient.GetAsync("api/satisfying", token);
var tolerating = httpClient.GetAsync("api/tolerating", token);
var frustrating = httpClient.GetAsync("api/frustrating", token);
await Task.WhenAll(satisfied, tolerating, frustrating);
},
token),
token);
Task.Run(
() => scheduler.Interval(
TimeSpan.FromSeconds(3),
TaskCreationOptions.None,
async() =>
{
var randomStatusCode = httpClient.GetAsync("api/randomstatuscode", token);
var exceptionThrower = httpClient.GetAsync("api/exceptionThrowing", token);
await Task.WhenAll(randomStatusCode, exceptionThrower);
},
token),
token);
Task.Run(
() => scheduler.Interval(
TimeSpan.FromSeconds(3),
TaskCreationOptions.None,
async() =>
{
await httpClient.GetAsync("api/test", token);
},
token),
token);
Task.Run(
() => scheduler.Interval(
TimeSpan.FromSeconds(2),
TaskCreationOptions.None,
async() =>
{
var putBytes = new ByteArrayContent(randomBufferGenerator.GenerateBufferFromSeed());
var putFormData = new MultipartFormDataContent {
{ putBytes, "put-file", "rnd-put" }
};
var putRequest = httpClient.PutAsync("api/file", putFormData, token);
var postBytes = new ByteArrayContent(randomBufferGenerator.GenerateBufferFromSeed());
var postFormData = new MultipartFormDataContent {
{ postBytes, "post-file", "rnd-post" }
};
var postRequest = httpClient.PostAsync("api/file", postFormData, token);
await Task.WhenAll(putRequest, postRequest);
},
token),
token);
}
public static void Main()
{
var cpuUsage = new CpuUsage();
cpuUsage.Start();
IServiceCollection serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
ConfigureMetrics(serviceCollection);
var process = Process.GetCurrentProcess();
var provider = serviceCollection.BuildServiceProvider();
var application = new Application(provider);
var scheduler = new DefaultTaskScheduler();
var simpleMetrics = new SampleMetrics(application.Metrics);
var setCounterSample = new SetCounterSample(application.Metrics);
var setMeterSample = new SetMeterSample(application.Metrics);
var userValueHistogramSample = new UserValueHistogramSample(application.Metrics);
var userValueTimerSample = new UserValueTimerSample(application.Metrics);
var cancellationTokenSource = new CancellationTokenSource();
//cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(10));
var task = scheduler.Interval(
TimeSpan.FromMilliseconds(300), TaskCreationOptions.LongRunning, () =>
{
using (application.Metrics.Measure.Apdex.Track(AppMetricsRegistry.ApdexScores.AppApdex))
{
setCounterSample.RunSomeRequests();
setMeterSample.RunSomeRequests();
userValueHistogramSample.RunSomeRequests();
userValueTimerSample.RunSomeRequests();
simpleMetrics.RunSomeRequests();
}
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.Gauges.Errors, () => 1);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.Gauges.PercentGauge, () => 1);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.Gauges.ApmGauge, () => 1);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.Gauges.ParenthesisGauge, () => 1);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.Gauges.GaugeWithNoValue, () => double.NaN);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.CpuUsageTotal, () =>
{
cpuUsage.CallCpu();
return(cpuUsage.CpuUsageTotal);
});
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.ProcessPagedMemorySizeGauge, () => process.PagedMemorySize64);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.ProcessPeekPagedMemorySizeGauge, () => process.PeakPagedMemorySize64);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.ProcessPeekVirtualMemorySizeGauge,
() => process.PeakVirtualMemorySize64);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.ProcessPeekWorkingSetSizeGauge, () => process.WorkingSet64);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.ProcessPrivateMemorySizeGauge, () => process.PrivateMemorySize64);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.ProcessVirtualMemorySizeGauge, () => process.VirtualMemorySize64);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.SystemNonPagedMemoryGauge, () => process.NonpagedSystemMemorySize64);
application.Metrics.Measure.Gauge.SetValue(AppMetricsRegistry.ProcessMetrics.SystemPagedMemorySizeGauge, () => process.PagedSystemMemorySize64);
}, cancellationTokenSource.Token);
application.Reporter.RunReports(application.Metrics, cancellationTokenSource.Token);
Console.WriteLine("Report Cancelled...");
Console.ReadKey();
}
