public override void Initialize(Models.Repository repository)
{
//create bucket
var bucketName = repository.GetBucketName();
if (!DatabaseHelper.ExistBucket(bucketName))
{
var cf = DatabaseHelper.GetCouchbaseClientConfiguration();
Bucket bucket = new Bucket();
bucket.Name = bucketName;
bucket.AuthType = AuthTypes.Sasl;
bucket.BucketType = BucketTypes.Membase;
bucket.Quota = new Quota() { RAM = DatabaseSettings.Instance.BucketRAM };//RamQuotaMB must be at least 100
bucket.FlushOption = FlushOptions.Enabled;//支持清空
bucket.ReplicaNumber = (ReplicaNumbers)DatabaseSettings.Instance.ReplicaNumber;
bucket.ReplicaIndex = DatabaseSettings.Instance.ReplicaIndex;
DatabaseHelper.CreateBucket(bucket);
//此处需暂停几秒钟，否则，通过选择模板创建站点的方式，在导入数据时，会出现数据未导入的情况
//大致原因在于，Couchbae在数据库创建之后，需要几秒钟的初始化过程，在这个过程中插入任何数据都将失败
System.Threading.Thread.Sleep(3000);
}
//always recreate the default view
repository.CreateDefaultViews();
base.Initialize(repository);
}
public void CreateBucket(Bucket bucket)
{
if (!bucket.IsValid())
{
var message = string.Join(Environment.NewLine, bucket.ValidationErrors.Values.ToArray());
throw new ArgumentException(message);
}
var query = GetCreateBucketQueryString(bucket);
HttpHelper.Post(_bucketUri, _username, _password, query, HttpHelper.CONTENT_TYPE_FORM);
}
private void CreateBucket()
{
Bucket bucket = new Bucket();
bucket.Name = cf.Bucket;
bucket.Password = cf.BucketPassword;
bucket.AuthType = AuthTypes.Sasl;
bucket.BucketType = BucketTypes.Membase;
bucket.Quota = new Quota() { RAM = 100 };
bucket.FlushOption = FlushOptions.Enabled;//支持清空
DatabaseHelper.CreateBucket(bucket);
}
public void CreateBucket(Bucket bucket)
{
if (!bucket.IsValid())
{
var message = string.Join(Environment.NewLine, bucket.ValidationErrors.Values.ToArray());
throw new ArgumentException(message);
}
var sb = new StringBuilder();
sb.AppendFormat("name={0}", bucket.Name);
sb.AppendFormat("&ramQuotaMB={0}", bucket.RamQuotaMB);
if (bucket.AuthType == AuthTypes.None)
sb.AppendFormat("&proxyPort={0}", bucket.ProxyPort);
if (bucket.AuthType == AuthTypes.Sasl && !string.IsNullOrEmpty(bucket.Password))
sb.AppendFormat("&saslPassword={0}", bucket.Password);
sb.AppendFormat("&authType={0}", Enum.GetName(typeof(AuthTypes), bucket.AuthType).ToLower()); ;
sb.AppendFormat("&bucketType={0}", Enum.GetName(typeof(BucketTypes), bucket.BucketType).ToLower());
sb.AppendFormat("&replicaNumber={0}", bucket.ReplicaNumber);
HttpHelper.Post(_bucketUri, _username, _password, sb.ToString(), HttpHelper.CONTENT_TYPE_FORM);
}
public void When_Try_Getting_Bucket_That_Bucket_Is_Not_Null()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
Cluster.CreateBucket(new Bucket
{
Name = bucketName,
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota { RAM = 100 },
ReplicaNumber = ReplicaNumbers.Zero
}
);
_bucket = tryWaitForBucket(bucketName);
Assert.That(_bucket, Is.Not.Null);
}
public void When_Managing_Design_Document_On_Non_Default_Bucket_Operation_Is_Successful()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
_bucket = new Bucket
{
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Name = bucketName,
Password = "******",
Quota = new Quota { RAM = 100 },
};
Cluster.CreateBucket(_bucket);
var createdBucket = waitForListedBucket(_bucket.Name);
Assert.That(createdBucket, Is.Not.Null);
var createResult = Cluster.CreateDesignDocument(_bucket.Name, "cities", new FileStream("Data\\CityViews.json", FileMode.Open));
Assert.That(createResult, Is.True);
var retrieveResult = Cluster.RetrieveDesignDocument(_bucket.Name, "cities");
Assert.That(retrieveResult, Is.Not.Null);
var deleteResult = Cluster.DeleteDesignDocument(_bucket.Name, "cities");
Assert.That(deleteResult, Is.True);
Cluster.DeleteBucket(_bucket.Name);
var deletedBucket = waitForListedBucket(_bucket.Name);
Assert.That(deletedBucket, Is.Null);
}
/// <summary>
/// @test: create bucket and then list the bucket, object graph should be populated
/// @pre: Default configuration to initialize client in app.config
/// @post: Test passes if graph is populated
/// </summary>
public void When_Listing_Bucket_Object_Graph_Is_Populated()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
_bucket = new Bucket
{
Name = bucketName,
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota {RAM = 100},
};
Cluster.CreateBucket(_bucket);
var bucket = waitForListedBucket(bucketName);
Assert.That(bucket, Is.Not.Null, "New bucket was null");
Assert.That(bucket.VBucketServerMap, Is.Not.Null);
Assert.That(bucket.VBucketServerMap.VBucketMap, Is.Not.Null);
Assert.That(bucket.Quota, Is.Not.Null);
Assert.That(bucket.DDocs, Is.Not.Null);
Assert.That(bucket.Controllers, Is.Not.Null);
Assert.That(bucket.BasicStats, Is.Not.Null);
var node = bucket.Nodes.FirstOrDefault();
Assert.That(node, Is.Not.Null, "Node was null");
Assert.That(node.MemoryTotal, Is.GreaterThan(0));
Assert.That(node.MemoryFree, Is.GreaterThan(0));
Assert.That(node.Replication, Is.GreaterThanOrEqualTo(0));
Assert.That(node.OS, Is.Not.Null);
Assert.That(node.Version, Is.Not.Null);
Cluster.DeleteBucket(bucketName);
_bucket = waitForListedBucket(bucketName);
Assert.That(bucket, Is.Null, "Deleted bucket still exists");
}
public void When_Getting_Invalid_Bucket_Web_Exception_Is_Thrown()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
_bucket = waitForBucket(bucketName);
Assert.That(_bucket, Is.Not.Null);
}
public void When_Getting_Cluster_Item_Count_Count_Matches_Interesting_Stats()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
Cluster.CreateBucket(new Bucket
{
Name = bucketName,
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota { RAM = 100 },
ReplicaNumber = ReplicaNumbers.Zero
}
);
_bucket = waitForBucket(bucketName);
Assert.That(_bucket, Is.Not.Null);
long count = Cluster.GetItemCount();
Assert.That(count, Is.EqualTo(_bucket.Nodes.FirstOrDefault().InterestingStats.Curr_Items_Tot));
}
public void When_Flushing_Bucket_Data_Are_Removed()
{
var storedConfig = ConfigurationManager.GetSection("couchbase") as ICouchbaseClientConfiguration;
var config = new CouchbaseClientConfiguration();
config.Bucket = "Bucket-" + DateTime.Now.Ticks;
config.Username = storedConfig.Username;
config.Password = storedConfig.Password;
config.Urls.Add(storedConfig.Urls[0]);
var cluster = new CouchbaseCluster(config);
cluster.CreateBucket(new Bucket
{
Name = config.Bucket,
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota { RAM = 100 },
ReplicaNumber = ReplicaNumbers.Zero,
FlushOption = FlushOptions.Enabled
}
);
for (int i = 0; i < 10; i++) //wait for bucket to be ready to accept ops
{
_bucket = waitForBucket(config.Bucket);
if (_bucket.Nodes.First().Status == "healthy") break;
Thread.Sleep(1000);
}
Assert.That(_bucket, Is.Not.Null);
using (var client = new CouchbaseClient(config))
{
var storeResult = client.ExecuteStore(StoreMode.Set, "SomeKey", "SomeValue");
Assert.That(storeResult.Success, Is.True, "Message: " + storeResult.Message);
var getResult = client.ExecuteGet<string>("SomeKey");
Assert.That(getResult.Success, Is.True);
Assert.That(getResult.Value, Is.StringMatching("SomeValue"));
cluster.FlushBucket(config.Bucket);
getResult = client.ExecuteGet<string>("SomeKey");
Assert.That(getResult.Success, Is.False);
Assert.That(getResult.Value, Is.Null);
}
}
public void UpdateBucket(Bucket bucket)
{
Bucket existingBucket;
if (! TryGetBucket(bucket.Name, out existingBucket))
{
if (existingBucket == null)
throw new ApplicationException("Failed to find bucket named" + bucket);
}
existingBucket.Quota.RAM = bucket.Quota.RAM == 0 ? existingBucket.Quota.RAM : bucket.Quota.RAM;
existingBucket.AuthType = bucket.AuthType == AuthTypes.Empty ? existingBucket.AuthType : bucket.AuthType;
existingBucket.ProxyPort = bucket.ProxyPort == 0 ? existingBucket.ProxyPort : bucket.ProxyPort;
existingBucket.BucketType = bucket.BucketType == BucketTypes.Empty ? existingBucket.BucketType : bucket.BucketType;
existingBucket.ReplicaNumber = bucket.ReplicaNumber == ReplicaNumbers.Empty ? existingBucket.ReplicaNumber : bucket.ReplicaNumber;
if (!existingBucket.IsValid())
{
var message = string.Join(Environment.NewLine, bucket.ValidationErrors.Values.ToArray());
throw new ArgumentException(message);
}
var query = GetCreateBucketQueryString(existingBucket, false);
HttpHelper.Post(UriHelper.Combine(_bucketUri, bucket.Name), _username, _password, query, HttpHelper.CONTENT_TYPE_FORM);
}
public void When_Creating_New_Memcached_Bucket_That_Bucket_Is_Listed()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
Cluster.CreateBucket(new Bucket
{
Name = bucketName,
AuthType = AuthTypes.None,
BucketType = BucketTypes.Memcached,
Quota = new Quota {RAM = 100},
ProxyPort = 9090,
ReplicaNumber = ReplicaNumbers.Zero
});
_bucket = waitForListedBucket(bucketName);
Assert.That(_bucket, Is.Not.Null);
}
public bool TryGetBucket(string bucketName, out Bucket bucket)
{
try
{
bucket = GetBucket(bucketName);
return true;
}
catch (Exception)
{
bucket = null;
return false;
}
}
public void When_Creating_New_Bucket_With_Existing_Name_Web_Exception_Is_Thrown()
{
var bucket = new Bucket
{
Name = "default",
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota {RAM = 128},
ReplicaNumber = ReplicaNumbers.Zero
};
Cluster.CreateBucket(bucket);
}
public void When_Creating_New_Bucket_With_Auth_Type_Sasl_And_Port_Argument_Exception_Is_Thrown()
{
var bucket = new Bucket
{
Name = "default",
AuthType = AuthTypes.None,
BucketType = BucketTypes.Memcached,
Quota = new Quota {RAM = 128},
ReplicaNumber = ReplicaNumbers.Zero
};
Cluster.CreateBucket(bucket);
}
public void When_Creating_New_Bucket_Item_Counts_Are_Set_On_Basic_Stats()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
_bucket = new Bucket
{
Name = bucketName,
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota {RAM = 100},
ReplicaNumber = ReplicaNumbers.Zero
};
Cluster.CreateBucket(_bucket);
_bucket = waitForListedBucket(bucketName);
Assert.That(_bucket, Is.Not.Null, "New bucket was null");
var count = _bucket.BasicStats.ItemCount;
Assert.That(count, Is.EqualTo(0), "Item count was not 0");
var client = new CouchbaseClient(bucketName, "");
var result = false;
for(var i = 0; i < 10; i++)
{
var aResult = client.ExecuteStore(StoreMode.Set, "a", "a");
var bResult = client.ExecuteStore(StoreMode.Set, "b", "b");
var cResult = client.ExecuteStore(StoreMode.Set, "c", "c");
result = aResult.Success & bResult.Success & cResult.Success;
if (result) break;
Thread.Sleep(2000); //wait for the bucket to be ready for writing
}
Assert.That(result, Is.True, "Store operations failed");
for (var i = 0; i < 10; i++)
{
_bucket = Cluster.ListBuckets().Where(b => b.Name == bucketName).FirstOrDefault();
count = _bucket.BasicStats.ItemCount;
if (count == 3) break;
Thread.Sleep(2000); //wait for the bucket to compute writes into basic stats
}
Assert.That(count, Is.EqualTo(3), "Item count was not 3");
Cluster.DeleteBucket(bucketName);
_bucket = waitForListedBucket(bucketName);
Assert.That(_bucket, Is.Null, "Deleted bucket still exists");
}
public bool TryListBuckets(out Bucket[] buckets)
{
try
{
buckets = ListBuckets();
return true;
}
catch (Exception)
{
buckets = null;
return false;
}
}
public void When_Updating_Bucket_That_Bucket_Is_Listed()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
Cluster.CreateBucket(new Bucket
{
Name = bucketName,
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota { RAM = 100 },
ReplicaNumber = ReplicaNumbers.Zero
});
_bucket = waitForListedBucket(bucketName);
Assert.That(_bucket, Is.Not.Null);
Cluster.UpdateBucket(new Bucket
{
Name = bucketName,
Quota = new Quota { RAM = 105 },
AuthType = AuthTypes.None,
ProxyPort = 8675
});
_bucket = waitForListedBucket(bucketName);
Assert.That(_bucket.Quota.RAM / 1024 / 1024, Is.EqualTo(105));
Assert.That(_bucket.ProxyPort, Is.EqualTo(8675));
Assert.That(_bucket.AuthType, Is.EqualTo(AuthTypes.None));
}
public void When_Deleting_Bucket_Bucket_Is_No_Longer_Listed()
{
var bucketName = "Bucket-" + DateTime.Now.Ticks;
_bucket = new Bucket
{
Name = bucketName,
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota {RAM = 100},
ReplicaNumber = ReplicaNumbers.Zero
};
Cluster.CreateBucket(_bucket);
_bucket = waitForListedBucket(bucketName);
Assert.That(_bucket, Is.Not.Null, "New bucket was null");
_bucket = waitForListedBucket(bucketName);
Assert.That(_bucket, Is.Null, "Deleted bucket still exists");
}
public void When_Creating_New_Bucket_With_Ram_Quota_Less_Than_100_Argument_Exception_Is_Thrown()
{
var bucket = new Bucket
{
Name = "default",
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Memcached,
Quota = new Quota {RAM = 99},
ReplicaNumber = ReplicaNumbers.Zero
};
Cluster.CreateBucket(bucket);
}
private string GetCreateBucketQueryString(Bucket bucket, bool includeName = true)
{
var sb = new StringBuilder();
if (includeName) sb.AppendFormat("name={0}&", bucket.Name);
sb.AppendFormat("ramQuotaMB={0}", bucket.Quota.RAM);
if (bucket.AuthType == AuthTypes.None)
sb.AppendFormat("&proxyPort={0}", bucket.ProxyPort);
if (bucket.AuthType == AuthTypes.Sasl && !string.IsNullOrEmpty(bucket.Password))
sb.AppendFormat("&saslPassword={0}", bucket.Password);
sb.AppendFormat("&authType={0}", Enum.GetName(typeof(AuthTypes), bucket.AuthType).ToLower()); ;
sb.AppendFormat("&bucketType={0}", Enum.GetName(typeof(BucketTypes), bucket.BucketType).ToLower());
sb.AppendFormat("&replicaNumber={0}", (short)bucket.ReplicaNumber);
sb.AppendFormat("&flushEnabled={0}", (short)bucket.FlushOption);
return sb.ToString();
}
