public async Task CreateBucket()
{
ICluster cluster = null;
//try to create bucket, if exists will just fail which is fine
try
{
cluster = await _clusterProvider.GetClusterAsync();
if (cluster != null)
{
var bucketSettings = new BucketSettings {
Name = _couchbaseConfig.BucketName,
BucketType = BucketType.Couchbase,
RamQuotaMB = 256,
};
await cluster.Buckets.CreateBucketAsync(bucketSettings);
}
else
{
throw new System.Exception("Can't create bucket - cluster is null, please check database configuration.");
}
}
catch (BucketExistsException)
{
_logger.LogWarning($"Bucket {_couchbaseConfig.BucketName} already exists");
}
catch (CouchbaseException ce)
{
_logger.LogError(ce.Message);
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message);
}
}
private async Task StoreTimingAsync(string name, DateTime time, int count, int totalDuration, int maxDuration, int minDuration, BucketSettings settings)
{
_logger.Trace(() => $"Storing timing name={name} count={count} total={totalDuration} min={minDuration} max={maxDuration} time={time}");
string countKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Count);
await _cache.IncrementAsync(countKey, count, settings.Ttl).AnyContext();
string totalDurationKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Total);
await _cache.IncrementAsync(totalDurationKey, totalDuration, settings.Ttl).AnyContext();
string maxKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Max);
await _cache.SetIfHigherAsync(maxKey, maxDuration, settings.Ttl).AnyContext();
string minKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Min);
await _cache.SetIfLowerAsync(minKey, minDuration, settings.Ttl).AnyContext();
_logger.Trace(() => $"Done storing timing name={name}");
}
private Task StoreTimingAsync(string name, DateTime time, int duration, BucketSettings settings)
{
return(StoreTimingAsync(name, time, 1, duration, duration, duration, settings));
}
private async Task StoreGaugeAsync(string name, DateTime time, int count, double total, double last, double min, double max, BucketSettings settings)
{
_logger.Trace(() => $"Storing gauge name={name} count={count} total={total} last={last} min={min} max={max} time={time}");
string countKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Count);
await _cache.IncrementAsync(countKey, count, settings.Ttl).AnyContext();
string totalDurationKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Total);
await _cache.IncrementAsync(totalDurationKey, total, settings.Ttl).AnyContext();
string lastKey = GetBucketKey(MetricNames.Gauge, name, time, settings.Size, MetricNames.Last);
await _cache.SetAsync(lastKey, last, settings.Ttl).AnyContext();
string minKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Min);
await _cache.SetIfLowerAsync(minKey, min, settings.Ttl).AnyContext();
string maxKey = GetBucketKey(MetricNames.Gauge, name, time, settings.Size, MetricNames.Max);
await _cache.SetIfHigherAsync(maxKey, max, settings.Ttl).AnyContext();
_logger.Trace(() => $"Done storing gauge name={name}");
}
private Task StoreGaugeAsync(string name, DateTime time, double value, BucketSettings settings)
{
return(StoreGaugeAsync(name, time, 1, value, value, value, value, settings));
}
public async Task InitializeAsync()
{
var opts = GetClusterOptions();
Cluster = await Couchbase.Cluster.ConnectAsync(
_settings.ConnectionString,
opts)
.ConfigureAwait(false);
var bucketSettings = new BucketSettings()
{
BucketType = BucketType.Couchbase,
Name = BucketName,
RamQuotaMB = 100,
NumReplicas = 0
};
try
{
await Cluster.Buckets.CreateBucketAsync(bucketSettings).ConfigureAwait(false);
}
catch (BucketExistsException)
{
}
catch (CouchbaseException ex) when(ex.ToString().Contains("already exists"))
{
}
catch (System.Net.Http.HttpRequestException)
{
// why did it fail?
}
catch (Exception ex)
{
throw;
}
try
{
var bucket = await Cluster.BucketAsync(BucketName);
try
{
await bucket.Collections.CreateScopeAsync(CustomScopeName);
await Task.Delay(5_000);
}
catch (ScopeExistsException)
{}
try
{
var collectionSpec = new CollectionSpec(scopeName: CustomScopeName, CustomCollectionName);
await bucket.Collections.CreateCollectionAsync(collectionSpec);
await Task.Delay(5_000);
}
catch (CollectionExistsException)
{}
}
catch
{
throw;
}
}
public void When_BucketStorage_NotSet_Return_Null()
{
var settings = new BucketSettings();
Assert.False(settings.ToFormValues().ContainsKey("storageBackend"));
}
private async Task StoreTimingAsync(string name, DateTime time, int count, int totalDuration, int maxDuration, int minDuration, BucketSettings settings) {
_logger.Trace(() => $"Storing timing name={name} count={count} total={totalDuration} min={minDuration} max={maxDuration} time={time}");
string countKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Count);
await _cache.IncrementAsync(countKey, count, settings.Ttl).AnyContext();
string totalDurationKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Total);
await _cache.IncrementAsync(totalDurationKey, totalDuration, settings.Ttl).AnyContext();
string maxKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Max);
await _cache.SetIfHigherAsync(maxKey, maxDuration, settings.Ttl).AnyContext();
string minKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Min);
await _cache.SetIfLowerAsync(minKey, minDuration, settings.Ttl).AnyContext();
_logger.Trace(() => $"Done storing timing name={name}");
}
private Task StoreTimingAsync(string name, DateTime time, int duration, BucketSettings settings) {
return StoreTimingAsync(name, time, 1, duration, duration, duration, settings);
}
private async Task StoreGaugeAsync(string name, DateTime time, int count, double total, double last, double min, double max, BucketSettings settings) {
_logger.Trace(() => $"Storing gauge name={name} count={count} total={total} last={last} min={min} max={max} time={time}");
string countKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Count);
await _cache.IncrementAsync(countKey, count, settings.Ttl).AnyContext();
string totalDurationKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Total);
await _cache.IncrementAsync(totalDurationKey, total, settings.Ttl).AnyContext();
string lastKey = GetBucketKey(MetricNames.Gauge, name, time, settings.Size, MetricNames.Last);
await _cache.SetAsync(lastKey, last, settings.Ttl).AnyContext();
string minKey = GetBucketKey(MetricNames.Timing, name, time, settings.Size, MetricNames.Min);
await _cache.SetIfLowerAsync(minKey, min, settings.Ttl).AnyContext();
string maxKey = GetBucketKey(MetricNames.Gauge, name, time, settings.Size, MetricNames.Max);
await _cache.SetIfHigherAsync(maxKey, max, settings.Ttl).AnyContext();
_logger.Trace(() => $"Done storing gauge name={name}");
}
private Task StoreGaugeAsync(string name, DateTime time, double value, BucketSettings settings) {
return StoreGaugeAsync(name, time, 1, value, value, value, value, settings);
}
private async Task StoreCounterAsync(string name, DateTime time, int value, BucketSettings settings) {
_logger.Trace(() => $"Storing counter name={name} value={value} time={time}");
string key = GetBucketKey(MetricNames.Counter, name, time, settings.Size);
await _cache.IncrementAsync(key, value, settings.Ttl).AnyContext();
AsyncManualResetEvent waitHandle;
_counterEvents.TryGetValue(name, out waitHandle);
waitHandle?.Set();
_logger.Trace(() => $"Done storing counter name={name}");
}
