public override void Run()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools/"));
config.Bucket = "beer-sample";
var client = new CouchbaseClient(config);
Console.WriteLine("Breweries by_name, limited to 10 records");
var view = client.GetView("breweries", "by_name").Limit(10);
Console.WriteLine("Breweries by_name, output the keys");
view = client.GetView("breweries", "by_name").Limit(10);
foreach (var item in view)
{
Console.WriteLine("Key: " + item.ViewKey.First());
}
Console.WriteLine("Breweries by_name, query by key range (y or Y)");
view = client.GetView("breweries", "by_name").StartKey("y").EndKey("z");
foreach (var item in view)
{
Console.WriteLine("Key: " + item.ViewKey.First());
}
Console.WriteLine("Breweries by_name, output the keys (y only)");
view = client.GetView("breweries", "by_name").StartKey("y").EndKey("Y");
foreach (var item in view)
{
Console.WriteLine("Key: " + item.ViewKey.First());
}
}
public DesignDocManager(CouchbaseClientConfiguration config)
{
if (_cluster == null)
{
_cluster = new CouchbaseCluster(config);
}
}
public ViewRunner(CouchbaseClientConfiguration config)
{
if (_client == null)
{
_client = new CouchbaseClient(config);
}
}
public override void Run()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools/"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
//add or replace a key
client.Store(StoreMode.Set, "key_1", 1);
Console.WriteLine(client.Get("key_1"));
var success = client.Store(StoreMode.Add, "key_1", 2);
Console.WriteLine(success); //will return false
success = client.Store(StoreMode.Replace, "key_1", 2);
Console.WriteLine(success); //will return true
success = client.Store(StoreMode.Replace, "key_2", 2);
Console.WriteLine(success); //will return false
//add a new key
client.Store(StoreMode.Set, "key_3", 1);
Console.WriteLine(client.Get("key_3"));
client.Remove("key_1");
client.Remove("key_2");
}
public override void Run()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools/"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
//Store a key, but don't return success until it is written
//to disk on the master (or times out)
var success = client.ExecuteStore(StoreMode.Set, "key_1", 2, PersistTo.One);
Console.WriteLine(success.Success); //will return false
//Store a key, but don't return success until it is
//replicated to 2 nodes (or times out)
//will fail on a single or two node cluster
success = client.ExecuteStore(StoreMode.Set, "key_1", 2, ReplicateTo.Two);
Console.WriteLine(success.Success); //will return false
//Store a key, but don't return success until it is written
//to disk on the master and replicated to 2 nodes (or times out)
//will fail on a single or two node cluster
success = client.ExecuteStore(StoreMode.Set, "key_1", 2, PersistTo.One, ReplicateTo.Two);
Console.WriteLine(success.Success); //will return false
client.Remove("key_1");
client.Remove("key_2");
}
static void AAAA()
{
//ITranscoder tr = new JsonTranscoder();
//Dump(tr.Serialize("a").Data);
//Dump(tr.Serialize(null).Data);
//Dump(tr.Serialize(1.0f).Data);
//Dump(tr.Serialize(2.4d).Data);
//Dump(tr.Serialize(08976543).Data);
//Dump(tr.Serialize(new { A = "a", B = 2, C = true, D = new[] { 1, 2, 3, 4 } }).Data);
//var o = tr.Deserialize(tr.Serialize(new Tmp { A = "a" }));
//Console.WriteLine(tr.Deserialize(tr.Serialize((Single)1)).GetType());
//Console.WriteLine(tr.Deserialize(tr.Serialize((Double)1)).GetType());
var mbc = new CouchbaseClientConfiguration();
mbc.Urls.Add(new Uri("http://192.168.47.128:8091/pools/default"));
var c = new CouchbaseClient(mbc);
// for (var i = 0; i < 10; i++) c.Store(StoreMode.Set, "json_" + i, i + 100);
//for (var i = 0; i < 10; i++) c.Store(StoreMode.Set, "binary_" + i, i + 100);
//for (var i = 0; i < 1000; i++)
// c.Store(StoreMode.Set, "key_" + i, i);
var r = c.GetView("test", "all").Limit(20);
var tmp = c.Get(r);
//Console.WriteLine(r.Count);
}
public static CouchbaseClientConfiguration CouchbaseConfiguration(string serverName)
{
var zone = Math.Max(ExecutionContext<RequestContext>.Current.Zone, 1);
var couchbaseClientConfiguration = new CouchbaseClientConfiguration();
var doc = XmlHelper.GetXmlDocCache(EndpointFile);
if (Equals(doc, null)) return couchbaseClientConfiguration;
var node = doc.SelectSingleNode("/configuration/couchbase[@zone='" + zone + "']/server[@name='" + serverName + "']");
if (Equals(node, null)) return couchbaseClientConfiguration;
couchbaseClientConfiguration.Bucket = XmlHelper.GetXmlAttributeValue(node, "bucket", "default");
couchbaseClientConfiguration.BucketPassword = XmlHelper.GetXmlAttributeValue(node, "password", string.Empty);
foreach (var item in node.ChildNodes.Cast<XmlNode>().Where(uri => uri.NodeType != XmlNodeType.Comment))
{
switch (item.Name)
{
case "urls":
foreach (var uri in item.ChildNodes.Cast<XmlNode>().Where(uri => uri.NodeType != XmlNodeType.Comment)) couchbaseClientConfiguration.Urls.Add(new Uri(XmlHelper.GetXmlAttributeValue(uri, "uri", string.Empty)));
break;
case "socketPool":
couchbaseClientConfiguration.SocketPool.MinPoolSize = CoreParse.GetInt32((XmlHelper.GetXmlAttributeValue(item, "minPoolSize", string.Empty)), 10);
couchbaseClientConfiguration.SocketPool.MaxPoolSize = CoreParse.GetInt32((XmlHelper.GetXmlAttributeValue(item, "maxPoolSize", string.Empty)), 20);
couchbaseClientConfiguration.SocketPool.ConnectionTimeout = TimeSpan.Parse(XmlHelper.GetXmlAttributeValue(item, "connectionTimeout", "00:00:02"));
couchbaseClientConfiguration.SocketPool.DeadTimeout = TimeSpan.Parse(XmlHelper.GetXmlAttributeValue(item, "deadTimeout", "00:00:10"));
couchbaseClientConfiguration.SocketPool.ReceiveTimeout = TimeSpan.Parse(XmlHelper.GetXmlAttributeValue(item, "receiveTimeout", "00:00:10"));
couchbaseClientConfiguration.SocketPool.QueueTimeout = TimeSpan.Parse(XmlHelper.GetXmlAttributeValue(item, "queueTimeout", "00:00:00.1000000"));
break;
}
}
return couchbaseClientConfiguration;
}
public override void Run()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://*****:*****@cia.gov",
Password = "******",
Logins = 0
};
var user2 = new User
{
Username = "******",
Name = "Nicholas Brody",
Email = "*****@*****.**",
Password = "******",
Logins = 0
};
//store the user - ExecuteStore returns detailed error info, if any
var result1 = client.ExecuteStore(StoreMode.Set, user1.Email, user1);
if (!result1.Success)
{
Console.WriteLine("Store failed with message {0} and status code {1}", result1.Message, result1.StatusCode);
if (result1.Exception != null)
{
throw result1.Exception;
}
}
var result2 = client.ExecuteStore(StoreMode.Set, user2.Email, user2);
//same check as result1 would be useful
var doc = client.Get<User>(user1.Email);
Console.WriteLine(doc.Name);
//get doc with extended info
var result = client.ExecuteGet<User>(user1.Email);
//update login count
doc.Logins += 1;
//update document (ignore errors for lab)
client.ExecuteStore(StoreMode.Replace, user1.Email, doc);
doc = client.Get<User>(user1.Email);
Console.WriteLine("User {0} had {1} logins", doc.Name, doc.Logins);
client.Remove(user1.Email);
client.Remove(user2.Email);
}
public void When_Using_Code_Config_And_Design_Document_Name_Transformer_Is_Not_Set_Production_Mode_Is_Default()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://10.0.0.79:8091/pools"));
var client = new CouchbaseClient(config); //client sets up transformer
Assert.That(config.DesignDocumentNameTransformer, Is.InstanceOf<ProductionModeNameTransformer>());
}
static LeaderBoardController()
{
var config = new CouchbaseClientConfiguration();
config.Bucket = "default";
config.Urls.Add(new Uri("http://192.168.2.1:8091/pools/"));
_client = new CouchbaseClient(config);
}
/// <summary>
/// Connects to couchbase client with given configuration details
/// </summary>
/// <param name="bucketName">Name of bucket to be used</param>
/// <param name="bucketPassword">Password used to connect to bucket</param>
/// <returns>Couchbase client object</returns>
private CouchbaseClient getClient(string bucketName, string bucketPassword)
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri(ConfigurationManager.AppSettings["CouchbaseServerUrl"] + "/pools"));
config.Bucket = bucketName;
config.BucketPassword = bucketPassword;
return new CouchbaseClient(config);
}
protected Tuple<CouchbaseClient, CouchbaseClientConfiguration> GetClientWithConfig(INameTransformer nameTransformer = null)
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri(ConfigurationManager.AppSettings["CouchbaseServerUrl"] + "/pools"));
config.Bucket = ConfigurationManager.AppSettings["CouchbaseServerUrl"];
config.DesignDocumentNameTransformer = nameTransformer ?? new DevelopmentModeNameTransformer();
config.HttpClientFactory = new MockHttpClientFactory();
return Tuple.Create(new CouchbaseClient(config), config);
}
public void SetUp()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools"));
config.DesignDocumentNameTransformer = new ProductionModeNameTransformer();
config.HttpClientFactory = new HammockHttpClientFactory();
config.Bucket = "default";
_Client = new CouchbaseClient(config);
}
/// <summary>
/// Connects to couchbase client with given configuration details
/// </summary>
/// <param name="bucketName">Name of bucket to be used</param>
/// <param name="bucketPassword">Password used to connect to bucket</param>
/// <returns>Couchbase client object</returns>
private CouchbaseClient getClient(string bucketName, string bucketPassword)
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri(ConfigurationManager.AppSettings["CouchbaseServerUrl"] + "/pools"));
config.Bucket = bucketName;
config.BucketPassword = bucketPassword;
config.DesignDocumentNameTransformer = new DevelopmentModeNameTransformer();
config.HttpClientFactory = new HammockHttpClientFactory();
return new CouchbaseClient(config);
}
protected Tuple<CouchbaseClient, CouchbaseClientConfiguration> GetClientWithConfig(INameTransformer nameTransformer = null)
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://10.0.0.79:8091/pools/default"));
config.Bucket = "default";
config.DesignDocumentNameTransformer = nameTransformer ?? new DevelopmentModeNameTransformer();
config.HttpClientFactory = new MockHttpClientFactory();
return Tuple.Create(new CouchbaseClient(config), config);
}
/// <summary>
/// Creates a utility object that can be used to perform operations against a Couchbase server.
/// Note:
/// Uses the authentication and bucket information from the supplied configuration item.
/// </summary>
/// <param name="configurationFolderPath">The path to the folder containing the encrypted configuration file containing information required to establish the connection to the server.</param>
/// <param name="configurationItemName">The name of configuration item containing the information required to connect to the server. (Typically it's filename without the extension.)</param>
public CouchbaseUtility(string configurationFolderPath, string configurationItemName)
{
if (!string.IsNullOrWhiteSpace(configurationFolderPath) && !string.IsNullOrWhiteSpace(configurationItemName))
{
ConfigurationItem configItem = new ConfigurationItem(configurationFolderPath, configurationItemName, true);
try
{
// Read the values required from the configuration file.
StringReader reader = new StringReader(configItem.Value);
string urlsLine = reader.ReadLine();
string[] urls = new string[] { };
if (!string.IsNullOrWhiteSpace(urlsLine))
{
urls = urlsLine.Split(',');
}
string bucket = reader.ReadLine();
string bucketPassword = reader.ReadLine();
if (urls.Length > 0 && !string.IsNullOrWhiteSpace(bucket) && !string.IsNullOrWhiteSpace(bucketPassword))
{
// Configure the client.
CouchbaseClientConfiguration config = new CouchbaseClientConfiguration();
foreach (string url in urls)
{
config.Urls.Add(new Uri(url));
}
config.Bucket = bucket;
config.BucketPassword = bucketPassword;
// Create a connection with the Couchbase bucket.
client = new CouchbaseClient(config);
}
else
{
throw new FormatException("Could not load configuration data from file. File is not of the correct format.");
}
}
catch
{
throw new FormatException("Could not load configuration data from file. File is not of the correct format.");
}
}
else
{
if (string.IsNullOrWhiteSpace(configurationFolderPath))
{
throw new ArgumentNullException("configurationFolderPath", "A path to a configuration items folder must be supplied.");
}
else
{
throw new ArgumentNullException("configurationItemName", "The name of the configuration item to load must be supplied.");
}
}
}
public StoreHandler(IEnumerable<Uri> uris, string bucketName, string bucketPassword)
{
var config = new CouchbaseClientConfiguration();
foreach (var uri in uris)
{
config.Urls.Add(uri);
}
config.Bucket = bucketName;
config.BucketPassword = bucketPassword;
_client=new CouchbaseClient(config);
}
/// <summary>
/// Connects to couchbase client with given configuration details
/// </summary>
/// <param name="username">Name of bucket to be used</param>
/// <param name="password">Password used to connect to bucket</param>
/// <returns>Couchbase client object</returns>
private CouchbaseClient getClient(string username, string password)
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools"));
config.Bucket = username;
config.BucketPassword = password;
config.DesignDocumentNameTransformer = new DevelopmentModeNameTransformer();
config.HttpClientFactory = new HammockHttpClientFactory();
return new CouchbaseClient(config);
}
public void When_Using_Code_Config_And_Http_Client_Factory_Is_Not_Set_Hammock_Factory_Is_Default()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://10.0.0.79:8091/pools"));
Assert.That(config.HttpClientFactory, Is.InstanceOf<HammockHttpClientFactory>());
//HammockHttpClient is an internal class to the Couchbase assembly,
//therefore the explicit type can't be checked for using Is.InstanceOf<T>
var typeName = (config.HttpClientFactory.Create(config.Urls[0], "", "").GetType().Name);
Assert.That(typeName, Is.StringContaining("HammockHttpClient"));
}
public static CouchbaseClientConfiguration GetCouchbaseClientConfiguration()
{
CouchbaseClientConfiguration cf = new CouchbaseClientConfiguration();
cf.Username = DatabaseSettings.Instance.Username;
cf.Password = DatabaseSettings.Instance.Password;
DatabaseSettings.Instance.Urls.ForEach((url, index) =>
{
cf.Urls.Add(url);
});
return cf;
}
public SourcePropertyChanges(string username, string password, params Uri[] couchbaseServers)
{
var config = new CouchbaseClientConfiguration
{
Bucket = username,
BucketPassword = password,
};
Array.ForEach(couchbaseServers, uri => config.Urls.Add(uri));
_couch = new CouchbaseClient(config);
_couch.NodeFailed += node => Console.WriteLine(node.ToString());
}
// ---------- PROPERTIES ----------
// ---------- CONSTRUCTORS ----------
/// <summary>
/// Creates a utility object that can be used to perform operations against a Couchbase server.
/// </summary>
/// <param name="config">A Couchbase configuration object initialized with information on how to connect to the server.</param>
public CouchbaseUtility(CouchbaseClientConfiguration config)
{
if (config != null)
{
// Create a connection with the Couchbase bucket.
client = new CouchbaseClient(config);
}
else
{
throw new ArgumentNullException("config", "A Couchbase Configuration object must be supplied.");
}
}
public void When_Removing_A_Key_From_A_Down_Node_No_Exception_Is_Thrown_And_Success_Is_False()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://doesnotexist:8091/pools/"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
var removeResult = client.ExecuteRemove("foo");
Assert.That(removeResult.Success, Is.False);
Assert.That(removeResult.Message, Is.StringContaining(ClientErrors.FAILURE_NODE_NOT_FOUND));
}
static void Main(string[] args)
{
CbcOptions options = new CbcOptions();
CommandLineParserSettings settings = new CommandLineParserSettings();
settings.CaseSensitive = true;
CommandLineParser parser = new CommandLineParser(settings);
if (!parser.ParseArguments(args, options, System.Console.Error))
{
return;
}
options.Process();
var config = new CouchbaseClientConfiguration();
config.Bucket = options.Bucket;
config.Username = options.Username;
config.Password = options.Password;
config.BucketPassword = options.BucketPassword;
string uriString = "http://" + options.Hostname + "/pools";
System.Console.WriteLine("URI: " + uriString);
config.Urls.Add(new UriBuilder(uriString).Uri);
DateTime begin = DateTime.Now;
CouchbaseClient cli = new CouchbaseClient(config);
System.Console.WriteLine("Created new client..");
if (!commandMap.ContainsKey(options.Command))
{
throw new ArgumentException("Unknown command!");
}
Type t = commandMap[options.Command];
Type[] proto = {
typeof(CouchbaseClient),
typeof(string),
typeof(CbcOptions)
};
object[] cargs = {
cli,
options.Key,
options
};
CommandBase cmd = (CommandBase) t.GetConstructor(proto).Invoke(cargs);
cmd.Execute();
var duration = DateTime.Now - begin;
Console.WriteLine(
String.Format("Duration was {0:F} Sec.", duration.TotalMilliseconds/1000));
}
static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure();
//Manually configure CouchbaseClient
//May also use app/web.config section
var config = new CouchbaseClientConfiguration();
config.Bucket = "default";
config.BucketPassword = "";
config.Urls.Add(new Uri("http://10.0.0.79:8091/pools"));
config.DesignDocumentNameTransformer = new ProductionModeNameTransformer();
config.HttpClientFactory = new HammockHttpClientFactory();
//Quick test of Store/Get operations
var client = new CouchbaseClient(config);
var result = client.Store(StoreMode.Set, "foo", "bar");
Debug.Assert(result, "Store failed");
Console.WriteLine("Item saved successfully");
var value = client.Get<string>("foo");
Debug.Assert(value == "bar", "Get failed");
Console.WriteLine("Item retrieved succesfully");
processJson(client);
Console.WriteLine("\r\n\r\n*** SAMPLE VIEWS MUST BE CREATED - SEE SampleViews.js in Data directory ***");
Console.WriteLine("\r\n\r\nRequesting view all_breweries");
var allBreweries = client.GetView<Brewery>("breweries", "all_breweries");
foreach (var item in allBreweries)
{
Console.WriteLine(item.Name);
}
Console.WriteLine("\r\n\r\nRequesting view beers_by_name");
var beersByName = client.GetView<Beer>("beers", "beers_by_name").StartKey("T");
foreach (var item in beersByName)
{
Console.WriteLine(item.Name);
}
Console.WriteLine("\r\n\r\nRequesting view beers_by_name_and_abv");
var beersByNameAndABV = client.GetView<Beer>("beers", "beers_by_name_and_abv")
.StartKey(new object[] { "T", 6 });
foreach (var item in beersByNameAndABV)
{
Console.WriteLine(item.Name);
}
}
public override void Load()
{
Bind<CouchbaseClient>().ToMethod(context =>
{
var config = new CouchbaseClientConfiguration
{
Bucket = "<bucket name to store object",
BucketPassword = "******"
};
config.Urls.Add(new Uri("http://localhost:8091/pools"));
return new CouchbaseClient(config);
});
Bind<IRepository>().To<CouchbaseRepository>();
}
public void Client_Operations_Succeed_When_Bootstrapping_To_Pools_Root_Uri()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public void Client_Operations_Succeed_When_Bootstrapping_To_Pools_Default_Root_Uri()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools/default"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
Assert.That(storeResult.Success, Is.True, "Success was false");
Assert.That(storeResult.Message, Is.Null.Or.Empty, "Message was not empty");
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public override void Run()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools/"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
//Store JSON
client.StoreJson(StoreMode.Set, "CT_Hartford", new City { Name = "Hartford", State = "CT" });
//Get City instance back from JSON
var city = client.GetJson<City>("CT_Hartford");
Console.WriteLine(city.Name);
client.Remove("CT_Hartford");
}
public static CouchbaseClient GetWriteInstance()
{
if (_instance1 == null)
{
lock (Lock1)
{
if (_instance1 == null)
{
var uri = new Uri("http://10.4.18.26:8091/pools");
var config = new CouchbaseClientConfiguration();
config.Urls.Add(uri);
config.Bucket = BucketName;
config.BucketPassword = BucketPassword;
_instance1 = new CouchbaseClient(config);
}
}
}
return _instance1;
}
