public async Task ScopeAsync_Throws_NotSupportedException_When_Name_Is_Not_Default()
{
var localhost = new Uri("http://10.112.192.102:8091");
var bucketConfig = ResourceHelper.ReadResource <BucketConfig>("mycache.json");
bucketConfig.Nodes.RemoveAt(1);
var mockClusterNode = new Mock <IClusterNode>();
mockClusterNode.Setup(x => x.EndPoint).Returns(localhost.GetIpEndPoint(8091, false));
mockClusterNode.Setup(x => x.BootstrapUri).Returns(localhost);
mockClusterNode.Setup(x => x.SelectBucket("default")).Returns(Task.CompletedTask);
var mockHttpClusterMap = new Mock <HttpClusterMapBase>();
mockHttpClusterMap.Setup(x =>
x.GetClusterMapAsync("default", localhost, CancellationToken.None)).
Returns(Task.FromResult(bucketConfig));
var bucket = new MemcachedBucket("default", new ClusterContext(), mockHttpClusterMap.Object);
await bucket.BootstrapAsync(mockClusterNode.Object).ConfigureAwait(false);
await Assert.ThrowsAsync <NotSupportedException>(async() =>
{
await bucket.ScopeAsync("xxxx").ConfigureAwait(false);
}).ConfigureAwait(false);
}
public async Task Indexer_Succeeds_When_Name_Is_Default()
{
var localhost = new Uri("http://10.112.192.102:8091");
var bucketConfig = ResourceHelper.ReadResource <BucketConfig>("mycache.json");
bucketConfig.Nodes.RemoveAt(1);
var mockClusterNode = new Mock <IClusterNode>();
mockClusterNode.Setup(x => x.EndPoint).Returns(localhost.GetIpEndPoint(8091, false));
mockClusterNode.Setup(x => x.BootstrapUri).Returns(localhost);
mockClusterNode.Setup(x => x.SelectBucket("default")).Returns(Task.CompletedTask);
var mockHttpClusterMap = new Mock <HttpClusterMapBase>();
mockHttpClusterMap.Setup(x =>
x.GetClusterMapAsync("default", localhost, CancellationToken.None)).
Returns(Task.FromResult(bucketConfig));
var bucket = new MemcachedBucket("default", new ClusterContext(), mockHttpClusterMap.Object);
await bucket.BootstrapAsync(mockClusterNode.Object).ConfigureAwait(false);
var scope = await bucket[BucketBase.DefaultScopeName].ConfigureAwait(false);
Assert.Equal(BucketBase.DefaultScopeName, scope.Name);
}
public void Setup()
{
var mockController = new Mock <IClusterController>();
mockController.Setup(x => x.Configuration).Returns(new ClientConfiguration());
_bucket = new MemcachedBucket(mockController.Object, string.Empty, new DefaultConverter(), new DefaultTranscoder(), null);
}
public async Task ViewQueryAsync_Throws_NotSupportedException()
{
var bucket = new MemcachedBucket("default", new ClusterContext());
await Assert.ThrowsAsync <NotSupportedException>(async() =>
{
await bucket.ViewQueryAsync("designDoc", "viewName").ConfigureAwait(false);
}).ConfigureAwait(false);
}
public async Task ScopeAsync_Succeeds_When_Name_Is_Default()
{
var bucket = new MemcachedBucket("default", new Configuration(), new ConfigContext(new Configuration()));
await bucket.Bootstrap().ConfigureAwait(false);
var scope = await bucket.ScopeAsync(BucketBase.DefaultScope).ConfigureAwait(false);
Assert.Equal(BucketBase.DefaultScope, scope.Name);
}
public async Task ScopeAsync_Throws_NotSupportedException_When_Name_Is_Not_Default()
{
var bucket = new MemcachedBucket("default", new Configuration(), new ConfigContext(new Configuration()));
await bucket.Bootstrap().ConfigureAwait(false);
await Assert.ThrowsAsync <NotSupportedException>(async() =>
{
await bucket.ScopeAsync("xxxx").ConfigureAwait(false);
}).ConfigureAwait(false);
}
public async Task <IBucket> BootstrapBucketAsync(string name, Uri uri, BucketType type)
{
var node = GetUnassignedNode(uri, ClusterOptions.EnableIPV6Addressing);
if (node == null)
{
var endpoint = uri.GetIpEndPoint(ClusterOptions.KvPort, ClusterOptions.UseInterNetworkV6Addresses);
node = await ClusterNode.CreateAsync(this, endpoint);
node.BootstrapUri = uri;
AddNode(node);
}
BucketBase bucket = null;
switch (type)
{
case BucketType.Couchbase:
case BucketType.Ephemeral:
bucket = new CouchbaseBucket(name, this);
break;
case BucketType.Memcached:
bucket = new MemcachedBucket(name, this);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
try
{
await bucket.BootstrapAsync(node);
RegisterBucket(bucket);
return(bucket);
}
catch (Exception e)
{
Log.LogError(e, @"Could not bootstrap {name}");
UnRegisterBucket(bucket);
throw;
}
}
public IBucket CreateBucket(string bucketName, string password)
{
var success = false;
IBucket bucket = null;
foreach (var provider in _configProviders)
{
try
{
Log.DebugFormat("Trying to boostrap with {0}.", provider);
var config = provider.GetConfig(bucketName, password);
switch (config.NodeLocator)
{
case NodeLocatorEnum.VBucket:
bucket = new CouchbaseBucket(this, bucketName, _converter, _serializer);
bucket.AddRef();
break;
case NodeLocatorEnum.Ketama:
bucket = new MemcachedBucket(this, bucketName, _converter, _serializer);
bucket.AddRef();
break;
default:
throw new ArgumentOutOfRangeException();
}
var configObserver = bucket as IConfigObserver;
if (provider.ObserverExists(configObserver))
{
Log.DebugFormat("Using existing bootstrap {0}.", provider);
configObserver.NotifyConfigChanged(config);
success = true;
break;
}
if (provider.RegisterObserver(configObserver) &&
_buckets.TryAdd(bucket.Name, bucket))
{
Log.DebugFormat("Successfully boostrap using {0}.", provider);
configObserver.NotifyConfigChanged(config);
success = true;
break;
}
configObserver.NotifyConfigChanged(config);
success = true;
break;
}
catch (BucketNotFoundException e)
{
Log.Warn(e);
}
catch (ConfigException e)
{
Log.Warn(e);
}
catch (AuthenticationException e)
{
Log.Warn(e);
break;
}
}
if (!success)
{
throw new ConfigException("Could not bootstrap {0}. See log for details.", bucketName);
}
return(bucket);
}
public async Task Indexer_Throws_NotSupportedException_When_Name_Is_Not_Default()
{
var bucket = new MemcachedBucket("default", new ClusterContext());
await Assert.ThrowsAsync <NotSupportedException>(async() => { await bucket["xxxxx"].ConfigureAwait(false); }).ConfigureAwait(false);
}
public void ViewIndexes_Throws_NotSupportedException()
{
var bucket = new MemcachedBucket("default", new ClusterContext());
Assert.Throws <NotSupportedException>(() => bucket.Views);
}
