private static IAuthenticator GetClassicAuthenticator()
{
var authenticator = new ClassicAuthenticator("Administrator", "password");
authenticator.AddBucketCredential("authenticated", "secret");
return(authenticator);
}
private void ConfigureInline(string name, System.Collections.Specialized.NameValueCollection config, ICouchbaseWebProvider provider)
{
var servers = ProviderHelper.GetAndRemoveAsArray(config, "servers", ';', false).Select(x => new Uri(x)).ToList();
var useSsl = ProviderHelper.GetAndRemoveAsBool(config, "useSsl", false);
var operationLifespan = ProviderHelper.GetAndRemoveAsUInt(config, "operationLifespan", false);
var sendTimeout = ProviderHelper.GetAndRemoveAsInt(config, "sendTimeout", false);
var connectTimeout = ProviderHelper.GetAndRemoveAsInt(config, "connectTimeout", false);
var minPoolSize = ProviderHelper.GetAndRemoveAsInt(config, "minPoolSize", false);
var maxPoolSize = ProviderHelper.GetAndRemoveAsInt(config, "maxPoolSize", false);
var username = ProviderHelper.GetAndRemove(config, "username", false);
var password = ProviderHelper.GetAndRemove(config, "password", false);
var clientConfig = new ClientConfiguration
{
DefaultOperationLifespan = operationLifespan ?? ClientConfiguration.Defaults.DefaultOperationLifespan,
UseSsl = useSsl ?? ClientConfiguration.Defaults.UseSsl,
Servers = servers.Any() ? servers : new List <Uri> {
new Uri("http://localhost:8091")
},
BucketConfigs = new Dictionary <string, BucketConfiguration>
{
{
provider.BucketName, new BucketConfiguration
{
BucketName = provider.BucketName,
PoolConfiguration = new PoolConfiguration
{
MinSize = minPoolSize ?? PoolConfiguration.Defaults.MinSize,
MaxSize = maxPoolSize ?? PoolConfiguration.Defaults.MaxSize,
SendTimeout = sendTimeout ?? PoolConfiguration.Defaults.SendTimeout,
ConnectTimeout = connectTimeout ?? PoolConfiguration.Defaults.ConnectTimeout
}
}
}
}
};
IAuthenticator authenticator = null;
if (string.IsNullOrWhiteSpace(username))
{
if (!string.IsNullOrWhiteSpace(password))
{
//assume pre-RBAC or CB < 5.0 if username is empty
authenticator = new ClassicAuthenticator(provider.BucketName, password);
}
}
else
{
if (!string.IsNullOrWhiteSpace(password))
{
authenticator = new PasswordAuthenticator(username, password);
}
}
MultiCluster.Configure(clientConfig, name, authenticator);
_log.Debug("Creating bucket: " + provider.BucketName);
provider.Bucket = MultiCluster.GetBucket(name, provider.BucketName);
}
public void ClassicAuthenticator_Can_Auth_Using_ConfigSection()
{
var cluster = new Cluster(configurationSectionName: "couchbaseClients/basic");
var auth = new ClassicAuthenticator
{
BucketCredentials = { { "authenticated", "secret" } }
};
cluster.Authenticate(auth);
Assert.IsNotNull(cluster.OpenBucket("authenticated"));
}
private static void Run(MeepMeepOptions options)
{
OutputWriter.Verbose = options.Verbose;
OutputWriter.Write("Running with options:");
OutputWriter.Write(options);
var config = new ClientConfiguration
{
Servers = options.Nodes.Select(x => new Uri(x)).ToList(),
PoolConfiguration = new PoolConfiguration
{
MinSize = options.PoolMin,
MaxSize = options.PoolMax
},
Transcoder = () => new DefaultTranscoder(),
OperationTracingEnabled = false,
OrphanedResponseLoggingEnabled = false,
UseSsl = options.UseSsl
};
if (!options.VerifySslCerts)
{
config.KvServerCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
}
using (var cluster = new Cluster(config))
{
var authenticator = new ClassicAuthenticator(options.ClusterUsername, options.ClusterPassword)
{
BucketCredentials = { { options.Bucket, options.BucketPassword } }
};
cluster.Authenticate(authenticator);
OutputWriter.Write("Connecting to cluster...");
var bucket = cluster.OpenBucket(options.Bucket);
if (options.FlushBucket)
{
OutputWriter.Write("Flushing bucket: {0}", options.Bucket);
var bucketManager = bucket.CreateManager();
bucketManager.Flush();
}
OutputWriter.Write("Running workloads...");
var workload = CreateWorkload(options);
var runner = CreateRunner(options);
runner.Run(workload, bucket, OnWorkloadCompleted).Wait();
}
OutputWriter.Write("Completed");
}
public void When_No_BucketCredentials_Defined_Throw_ArgumentException()
{
var config = TestConfiguration.GetCurrentConfiguration();
var cluster = new Cluster(config);
var cred = new ClassicAuthenticator("Administrator", "password");
//cred.AddBucketCredential("buck", "");
//cred.AddBucketCredential("travel-sample", "");
Assert.Throws <ArgumentException>(() => cluster.Authenticate(cred));
}
public void Can_Authenticate_With_ClassicAuthenticator()
{
var clusterMock = new Mock <ICluster>();
clusterMock.Setup(x => x.OpenBucket(It.IsAny <string>())).Returns(new Mock <IBucket>().Object);
clusterMock.Setup(x => x.Authenticate(It.IsAny <IAuthenticator>()));
var cluster = clusterMock.Object;
var authenticator = new ClassicAuthenticator("administrator", "password");
cluster.Authenticate(authenticator);
var bucket = cluster.OpenBucket("defualt");
Assert.IsNotNull(bucket);
}
public void ConnecttoBucket(string bucketName)
{
var clusterMan = clusterCB.CreateManager(Db.UserCalculated.ToString(), Db.PassCalculated.ToString());
IList <BucketConfig> buckets = clusterMan.ListBuckets().Value;
string bucketpassword = (from buckConfig in buckets where buckConfig.Name == bucketName select buckConfig.SaslPassword).FirstOrDefault();
if (bucketpassword == null)
{
throw new Exception("No bucket found with name " + bucketName);
}
ClassicAuthenticator classicAuthenticator = new ClassicAuthenticator("Administrator", "Administrator");
classicAuthenticator.AddBucketCredential(bucketName, bucketpassword);
clusterCB.Authenticate(classicAuthenticator);
}
public bool ConnecttoBucket(string bucketName)
{
try
{
var bucket = clusterCB.OpenBucket(bucketName);
string bucketpassword = bucket.Configuration.Password;
ClassicAuthenticator classicAuthenticator = new ClassicAuthenticator(User, Password);
classicAuthenticator.AddBucketCredential(bucketName, bucketpassword);
clusterCB.Authenticate(classicAuthenticator);
//TODO: need to check and true and flase on basis of connection
return(true);
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, "Failed To Connect ConnectToBucket Method In GingerCouchBase DB", ex);
return(false);
}
}
public bool ConnectToBucket(string bucketName)
{
try
{
var bucket = clusterCB.OpenBucket(bucketName);
string bucketpassword = bucket.Configuration.Password;
ClassicAuthenticator classicAuthenticator = new ClassicAuthenticator(Db.DatabaseOperations.UserCalculated.ToString(), Db.DatabaseOperations.PassCalculated.ToString());
classicAuthenticator.AddBucketCredential(bucketName, bucketpassword);
clusterCB.Authenticate(classicAuthenticator);
//TODO: need to check and true and flase on basis of connection
return(true);
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {ex.Message}", ex);
return(false);
}
}
public void Legacy_Credentials_Sets_ClassicAuthenticator_Properties()
{
var credentials = new ClusterCredentials
{
ClusterUsername = "******",
ClusterPassword = "",
BucketCredentials = new Dictionary <string, string>
{
{ "default", "" },
{ "authenticated", "secret" },
{ "memcached", "" },
{ "travel-sample", "wayward1" }
}
};
var authenticator = new ClassicAuthenticator(credentials);
Assert.AreEqual(credentials.ClusterUsername, authenticator.ClusterUsername);
Assert.AreEqual(credentials.ClusterPassword, authenticator.ClusterPassword);
CollectionAssert.AreEquivalent(credentials.BucketCredentials, authenticator.BucketCredentials);
}
public void ClassicAuthenticator_Can_Create_ClusterManager_With_Username_From_ConnectionString()
{
const string username = "******";
var config = TestConfiguration.GetDefaultConfiguration();
// update server uri's to add the username segment
config.Servers = config.Servers.Select(x => InsertUsernameIntoUri(x, username)).ToList();
// create authenticator without username
var authenticator = new ClassicAuthenticator("password");
var cluster = new Cluster(config);
cluster.Authenticate(authenticator);
var clusterManager = cluster.CreateManager();
var listbucketsResult = clusterManager.ListBuckets();
Assert.IsNotNull(clusterManager);
Assert.IsTrue(listbucketsResult.Success);
Assert.IsTrue(listbucketsResult.Value.Any());
}
