public override void Init(int flowCount, long flowRecordCount)
{
ConnectionString = ConnectionString == null ? "localhost" : ConnectionString;
sessions = new ISession[flowCount];
cluster = Cluster.Builder().AddContactPoint(ConnectionString).Build();
ISession session = cluster.Connect();
session.DeleteKeyspaceIfExists(KeySpace);
session.CreateKeyspace(KeySpace);
session.ChangeKeyspace(KeySpace);
sessions[0] = session;
for (int i = 0; i < flowCount; i++)
{
session = cluster.Connect();
session.ChangeKeyspace(KeySpace);
sessions[i] = session;
}
sessions[0].Execute(GetCreateTableQuery(CollectionName));
if (ConnectionString == "localhost")
{
DataDirectory = Path.Combine(GetConfigFilePath(), "data\\data");
}
}
public void Add(Staff staff)
{
using (var session = _cassandraCluster.Connect(KeySpace))
{
session.Execute($"insert into staff (Id, FirstName, LastName, Birthday, Position, Salary) values({staff.Id}, '{staff.FirstName}', '{staff.LastName}', '2016-04-06', '{staff.Position}', {staff.Salary});");
var unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
session.Execute($"insert into lifetimes (Id, staff_Id, time) values({staff.Id}, {staff.Id}, '{unixTimestamp.ToString()}');");
}
}
private ICluster CreateClusterAndWaitUntilConnectException(Action <Builder> b, out Exception ex)
{
Exception tempEx = null;
ICluster cluster = null;
TestHelper.RetryAssert(
() =>
{
var builder = Cluster.Builder().AddContactPoints(TestCluster.ContactPoints);
b(builder);
cluster = builder.Build();
try
{
tempEx = Assert.Catch <Exception>(() => cluster.Connect());
}
catch (Exception)
{
cluster.Dispose();
SetupNewTestCluster();
Interlocked.MemoryBarrier();
TestCluster.DisableConnectionListener(type: "reject_startup");
throw;
}
}, 500, 20);
Interlocked.MemoryBarrier();
ex = tempEx;
return(cluster);
}
public void ExecuteGraph_Should_Build_Payload_With_GraphOptions()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(
stmt => coreStatement = stmt,
new GraphOptions()
.SetName("name1")
.SetSource("My source!")
.SetReadTimeoutMillis(22222)
.SetReadConsistencyLevel(ConsistencyLevel.LocalQuorum)
.SetWriteConsistencyLevel(ConsistencyLevel.EachQuorum));
var session = _cluster.Connect();
session.ExecuteGraph(new SimpleGraphStatement("g.V()"));
Assert.NotNull(coreStatement);
Assert.NotNull(coreStatement.OutgoingPayload);
Assert.That(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-source"]), Is.EqualTo("My source!"));
Assert.AreEqual(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-name"]), "name1");
Assert.AreEqual(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-read-consistency"]), "LOCAL_QUORUM");
Assert.AreEqual(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-write-consistency"]), "EACH_QUORUM");
//default
Assert.AreEqual(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-language"]), "gremlin-groovy");
Assert.That(coreStatement.OutgoingPayload["request-timeout"], Is.EqualTo(ExecuteGraphTests.ToBuffer(22222)));
}
public void TokenMap_Should_RebuildTokenMap_When_NodeIsBootstrapped(bool metadataSync)
{
TestCluster = TestClusterManager.CreateNew(2, new TestClusterOptions {
UseVNodes = true
});
var keyspaceName = TestUtils.GetUniqueKeyspaceName().ToLower();
ClusterObj = Cluster.Builder()
.AddContactPoint(TestCluster.InitialContactPoint)
.WithMetadataSyncOptions(new MetadataSyncOptions().SetMetadataSyncEnabled(metadataSync))
.Build();
var session = ClusterObj.Connect();
var createKeyspaceCql = $"CREATE KEYSPACE {keyspaceName} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor' : 3}}";
session.Execute(createKeyspaceCql);
TestUtils.WaitForSchemaAgreement(ClusterObj);
session.ChangeKeyspace(keyspaceName);
var replicas = ClusterObj.Metadata.GetReplicas(keyspaceName, Encoding.UTF8.GetBytes("123"));
Assert.AreEqual(metadataSync ? 2 : 1, replicas.Count);
Assert.AreEqual(2, ClusterObj.Metadata.Hosts.Count);
var oldTokenMap = ClusterObj.Metadata.TokenToReplicasMap;
this.TestCluster.BootstrapNode(3);
TestHelper.RetryAssert(() =>
{
Assert.AreEqual(3, ClusterObj.Metadata.Hosts.Count);
replicas = ClusterObj.Metadata.GetReplicas(keyspaceName, Encoding.UTF8.GetBytes("123"));
Assert.AreEqual(metadataSync ? 3 : 1, replicas.Count);
Assert.IsFalse(object.ReferenceEquals(ClusterObj.Metadata.TokenToReplicasMap, oldTokenMap));
}, 100, 150);
}
protected AnimalCassandraFactory(string keyspace, ILogger logger, IConsulService consulService)
{
var contactPoint = consulService.Get("Hosts/Cassandra/Host").GetAwaiter().GetResult();
var contactPort = consulService.Get("Hosts/Cassandra/Port").GetAwaiter().GetResult();
int portNumber;
if (!int.TryParse(contactPort, out portNumber))
{
throw new InvalidOperationException("Cassndra's port number is not valid.");
}
var stopWatch = Stopwatch.StartNew();
cluster = Cluster.Builder()
.AddContactPoints(contactPoint.Split(',').Where(x => !string.IsNullOrWhiteSpace(x)))
.WithPort(portNumber)
.WithCompression(CompressionType.Snappy)
.Build();
Session = cluster.Connect(keyspace);
stopWatch.Stop();
logger.Debug(null, $"CassandraProvider.ctor('{keyspace}') ⌚{stopWatch.ElapsedMilliseconds}ms").GetAwaiter()
.GetResult();
Logger = logger;
this.consulService = consulService;
Task.Run(PrepareStatements).GetAwaiter().GetResult();
}
protected override void CreateCommonSession()
{
Exception last = null;
for (var i = 0; i < SharedCloudClusterTest.MaxRetries; i++)
{
try
{
Cluster = CreateCluster();
SetBaseSession(Cluster.Connect());
return;
}
catch (Exception ex)
{
last = ex;
Task.Delay(1000).GetAwaiter().GetResult();
if (Cluster != null)
{
Cluster.Dispose();
Cluster = null;
}
}
}
throw last;
}
public void ClusterConnect()
{
while (Cluster == null)
{
try
{
Cluster = ProxyClient.Create <ICluster>(m_RemoteURI);
if (Cluster != null)
{
var configuration = WorldServiceLocator._ConfigurationProvider.GetConfiguration();
if (Cluster.Connect(LocalURI, configuration.Maps.Select(x => Conversions.ToUInteger(x)).ToList()))
{
break;
}
Cluster.Disconnect(LocalURI, configuration.Maps.Select(x => Conversions.ToUInteger(x)).ToList());
}
}
catch (Exception ex)
{
var e = ex;
WorldServiceLocator._WorldServer.Log.WriteLine(LogType.FAILED, "Unable to connect to cluster. [{0}]", e.Message);
}
Cluster = null;
Thread.Sleep(3000);
}
WorldServiceLocator._WorldServer.Log.WriteLine(LogType.SUCCESS, "Contacted cluster [{0}]", m_RemoteURI);
}
public void ExecuteGraph_Should_Build_Payload_With_Statement_Properties()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(
stmt => coreStatement = stmt,
new GraphOptions()
.SetName("name1")
.SetSource("My source!")
.SetReadConsistencyLevel(ConsistencyLevel.LocalQuorum)
.SetWriteConsistencyLevel(ConsistencyLevel.EachQuorum));
var session = _cluster.Connect();
session.ExecuteGraph(new SimpleGraphStatement("g.V()")
.SetGraphLanguage("my-lang")
.SetReadTimeoutMillis(5555)
.SetSystemQuery()
.SetGraphReadConsistencyLevel(ConsistencyLevel.Two)
.SetGraphSource("Statement source"));
Assert.NotNull(coreStatement);
Assert.NotNull(coreStatement.OutgoingPayload);
Assert.That(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-source"]), Is.EqualTo("Statement source"));
//is a sistem query
Assert.False(coreStatement.OutgoingPayload.ContainsKey("graph-name"));
Assert.AreEqual(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-read-consistency"]), "TWO");
Assert.AreEqual(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-write-consistency"]), "EACH_QUORUM");
Assert.AreEqual(Encoding.UTF8.GetString(coreStatement.OutgoingPayload["graph-language"]), "my-lang");
Assert.That(coreStatement.OutgoingPayload["request-timeout"], Is.EqualTo(ExecuteGraphTests.ToBuffer(5555)));
}
public void ClusterConnect()
{
while (Cluster == null)
{
try
{
Cluster = ProxyClient.Create <ICluster>(m_RemoteURI);
if (!Information.IsNothing(Cluster))
{
WorldServerConfiguration configuration = WorldServiceLocator._ConfigurationProvider.GetConfiguration();
if (Cluster.Connect(LocalURI, configuration.Maps.Select(_Closure_0024__._0024I13_002D0 ??= x => Conversions.ToUInteger(x)).ToList()))
{
break;
}
Cluster.Disconnect(LocalURI, configuration.Maps.Select(_Closure_0024__._0024I13_002D1 ??= x => Conversions.ToUInteger(x)).ToList());
}
}
catch (Exception ex)
{
ProjectData.SetProjectError(ex);
Exception e = ex;
WorldServiceLocator._WorldServer.Log.WriteLine(LogType.FAILED, "Unable to connect to cluster. [{0}]", e.Message);
ProjectData.ClearProjectError();
}
Cluster = null;
Thread.Sleep(3000);
}
WorldServiceLocator._WorldServer.Log.WriteLine(LogType.SUCCESS, "Contacted cluster [{0}]", m_RemoteURI);
}
public Worker(ILogger <Worker> logger)
{
_cluster = Cluster.Builder().AddContactPoint("127.0.0.1").Build();
// create session
_session = _cluster.Connect();
_logger = logger;
}
public void ExecuteGraph_Should_Wrap_RowSet()
{
var rowMock1 = new Mock <Row>();
rowMock1.Setup(r => r.GetValue <string>(It.Is <string>(n => n == "gremlin"))).Returns("{\"result\": 100}");
var rowMock2 = new Mock <Row>();
rowMock2.Setup(r => r.GetValue <string>(It.Is <string>(n => n == "gremlin"))).Returns("{\"result\": 101}");
IEnumerable <Row> rows = new[]
{
rowMock1.Object,
rowMock2.Object
};
var rsMock = new Mock <RowSet>();
rsMock.Setup(r => r.GetEnumerator()).Returns(() => rows.GetEnumerator());
_cluster = ExecuteGraphTests.GetCluster(stmt => { }, null, rsMock.Object);
var session = _cluster.Connect();
var rsGraph = session.ExecuteGraph(new SimpleGraphStatement("g.V()"));
Assert.NotNull(rsGraph);
var resultArray = rsGraph.ToArray();
Assert.AreEqual(2, resultArray.Length);
CollectionAssert.AreEqual(new[] { 100, 101 }, resultArray.Select(g => g.ToInt32()));
}
public void TestFixtureSetUp()
{
var testCluster = TestClusterManager.GetTestCluster(1);
_cluster = Cluster.Builder().AddContactPoint(testCluster.InitialContactPoint).Build();
_session = _cluster.Connect();
_uniqueKsName = TestUtils.GetUniqueKeyspaceName();
_session.CreateKeyspace(_uniqueKsName);
_session.ChangeKeyspace(_uniqueKsName);
}
public UnitStop Get(int id)
{
using (var session = _cluster.Connect(KeySpace))
{
Row res = session.Execute($"select * from bus_stops where id = {id};").FirstOrDefault();
if (res == null)
{
return(null);
}
return(new UnitStop
{
Id = id,
Title = res.GetValue <string>("title"),
Latitude = res.GetValue <double>("latitude"),
Longitude = res.GetValue <double>("longitude")
});
}
}
public void OneTimeSetUp()
{
Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Verbose;
var ip = Environment.GetEnvironmentVariable("YB_CLUSTER_ADDRESS");
_cluster = Cluster.Builder().AddContactPoint(ip).Build();
_session = _cluster.Connect();
_session.Execute("CREATE KEYSPACE IF NOT EXISTS test");
_session.Execute("USE test");
}
public void TestFixtureSetUp()
{
var testCluster = TestClusterManager.GetTestCluster(1);
_cluster = Cluster.Builder().AddContactPoint(testCluster.InitialContactPoint).Build();
_session = _cluster.Connect();
_uniqueKsName = TestUtils.GetUniqueKeyspaceName();
_session.CreateKeyspace(_uniqueKsName);
_session.ChangeKeyspace(_uniqueKsName);
}
public void TestFixtureSetUp()
{
var testCluster = TestClusterManager.GetTestCluster(1, DefaultMaxClusterCreateRetries, true, false);
_cluster = Cluster.Builder().AddContactPoint(testCluster.InitialContactPoint).Build();
_session = _cluster.Connect();
_session.CreateKeyspace(_uniqueKsName);
_session.ChangeKeyspace(_uniqueKsName);
_movieTable = new Table<Movie>(_session, new MappingConfiguration());
_movieTable.Create();
}
public void OneTimeSetUp()
{
TestClusterManager.CreateNew(1, new TestClusterOptions {
Workloads = new[] { "graph" }
});
CreateClassicGraph(TestClusterManager.InitialContactPoint, GraphTests.GraphName);
_cluster = ClusterBuilder()
.AddContactPoint(TestClusterManager.InitialContactPoint)
.WithGraphOptions(new GraphOptions().SetName(GraphTests.GraphName))
.Build();
_session = _cluster.Connect();
}
public void TestFixtureSetUp()
{
var testCluster = TestClusterManager.GetTestCluster(1, DefaultMaxClusterCreateRetries, true, false);
_cluster = Cluster.Builder().AddContactPoint(testCluster.InitialContactPoint).Build();
_session = _cluster.Connect();
_session.CreateKeyspace(_uniqueKsName);
_session.ChangeKeyspace(_uniqueKsName);
_movieTable = new Table <Movie>(_session, new MappingConfiguration());
_movieTable.Create();
}
public void ExecuteGraph_Should_Call_ExecuteAsync_With_SimpleStatement()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(stmt => coreStatement = stmt);
var session = _cluster.Connect();
session.ExecuteGraph(new SimpleGraphStatement("g.V()"));
Assert.NotNull(coreStatement);
Assert.Null(coreStatement.Timestamp);
Assert.Null(coreStatement.ConsistencyLevel);
Assert.AreEqual("g.V()", coreStatement.QueryString);
}
public void StandardCreds_DseAuth_AuthSuccess()
{
var builder = Cluster.Builder()
.AddContactPoint(_testClusterForDseAuthTesting.Value.InitialContactPoint)
.WithCredentials("cassandra", "cassandra");
_cluster = builder.Build();
var session = _cluster.Connect();
var rs = session.Execute("SELECT * FROM system.local");
Assert.Greater(rs.Count(), 0);
}
public DataRepository(ICluster cluster)
{
_cluster = cluster;
this._session = _cluster.Connect(KEY_SPACE);
var select = string.Format(
"SELECT * FROM {0}.{1} WHERE {2} = ? AND {3} >= ? AND {3} <= ?", KEY_SPACE,
TABLE, SENSOR_ID, TS);
this._prepared_select = _session.Prepare(select);
this._prepared_insert =
_session.Prepare(String.Format("INSERT INTO {0}.{1} ({2}, {3}, {4}) VALUES (?, ?, ?)", KEY_SPACE,
TABLE, SENSOR_ID, TS, TEMP));
}
public void ExecuteGraph_Should_Allow_BigInteger_As_Parameters()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(stmt => coreStatement = stmt);
var session = _cluster.Connect();
var value = BigInteger.Parse("1234567890123456789123456789");
session.ExecuteGraph(new SimpleGraphStatement("g.V(vertexId)", new { value }));
Assert.NotNull(coreStatement);
Assert.AreEqual(1, coreStatement.QueryValues.Length);
Assert.AreEqual("{\"value\":" + value + "}", coreStatement.QueryValues[0]);
}
public void ExecuteGraph_Should_Call_ExecuteAsync_With_Timestamp_Set()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(stmt => coreStatement = stmt);
var session = _cluster.Connect();
var timestamp = DateTimeOffset.Now;
session.ExecuteGraph(new SimpleGraphStatement("g.V()").SetTimestamp(timestamp));
Assert.NotNull(coreStatement);
Assert.Null(coreStatement.ConsistencyLevel);
Assert.AreEqual(coreStatement.Timestamp, timestamp);
}
public void ExecuteGraph_Should_Allow_IpAddress_As_Parameters()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(stmt => coreStatement = stmt);
var session = _cluster.Connect();
var value = IPAddress.Parse("192.168.1.100");
session.ExecuteGraph(new SimpleGraphStatement("g.V(vertexId)", new { value }));
Assert.NotNull(coreStatement);
Assert.AreEqual(1, coreStatement.QueryValues.Length);
Assert.AreEqual("{\"value\":\"" + value + "\"}", coreStatement.QueryValues[0]);
}
public void ExecuteGraph_Should_Call_ExecuteAsync_With_ConsistencyLevel_Set()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(stmt => coreStatement = stmt);
var session = _cluster.Connect();
const ConsistencyLevel consistency = ConsistencyLevel.Three;
session.ExecuteGraph(new SimpleGraphStatement("g.V()").SetConsistencyLevel(consistency));
Assert.NotNull(coreStatement);
Assert.AreEqual(coreStatement.ConsistencyLevel, consistency);
Assert.Null(coreStatement.Timestamp);
}
public static void Setup()
{
_cluster = Cluster.Builder()
.AddContactPoint(ConfigurationManager.AppSettings["ContactPoint"] ?? "127.0.0.1")
.Build();
_session = _cluster.Connect();
_session.Execute("DROP KEYSPACE IF EXISTS web_load_testing_1");
_session.Execute("CREATE KEYSPACE web_load_testing_1 WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};");
_session.ChangeKeyspace("web_load_testing_1");
_session.Execute("CREATE TABLE tbl1 (id uuid primary key, val text)");
_psInsert = _session.Prepare("INSERT INTO tbl1 (id, val) VALUES (?, ?)");
_psSelect = _session.Prepare("SELECT id, val from tbl1 LIMIT 10");
}
public void ExecuteGraph_Should_Build_Payload_With_Default_Values()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(stmt => coreStatement = stmt);
var session = _cluster.Connect();
session.ExecuteGraph(new SimpleGraphStatement("g.V()"));
Assert.NotNull(coreStatement);
Assert.NotNull(coreStatement.OutgoingPayload);
//The default graph payload
Assert.AreEqual(2, coreStatement.OutgoingPayload.Count);
CollectionAssert.AreEqual(new[] { "graph-language", "graph-source" }, coreStatement.OutgoingPayload.Keys);
}
public override bool TestConnection(DataContainer container)
{
Dictionary <string, string> connectionStringValues = GetConnectionStringValues(container.ConnectionString);
try {
ICluster _cluster = Cluster.Builder().AddContactPoint(connectionStringValues["address"]).Build();
_cluster.Connect();
return(true);
}
catch (Exception)
{
return(false);
}
}
public override List <string> CollectSample(DataEntity dataEntity, int sampleSize)
{
var result = new List <string>();
Dictionary <string, string> connectionStringValues = GetConnectionStringValues(dataEntity.Container.ConnectionString);
try
{
ICluster _cluster = Cluster.Builder().AddContactPoint(connectionStringValues["address"]).Build();
ISession _session = _cluster.Connect();
_session.Execute("USE " + connectionStringValues["keyspace"]);
string query = $"SELECT {dataEntity.Name} FROM {dataEntity.Collection.Name} LIMIT {sampleSize}";
RowSet res = _session.Execute(query);
var rows = res.GetRows().ToList();
if (rows.Count() > 0)
{
foreach (Row row in rows)
{
if (dataEntity.DbDataType.Equals(ColumnTypeCode.Text.ToString()))
{
result.Add(row.GetValue <string>(dataEntity.Name));
}
else if (dataEntity.DbDataType.Equals(ColumnTypeCode.List.ToString()))
{
var list = row.GetValue <List <string> >(dataEntity.Name);
foreach (var item in list)
{
result.Add(item);
}
}
else if (dataEntity.DbDataType.Equals(ColumnTypeCode.Map.ToString()))
{
var list = row.GetValue <IDictionary <string, int> >(dataEntity.Name);
foreach (var item in list)
{
result.Add(item.Key.ToString());
}
}
}
}
return(result);
}
catch (Exception)
{
return(result);
}
}
public void ExecuteGraph_Should_Call_ExecuteAsync_With_ReadTimeout_Set_From_Statement()
{
const int defaultReadTimeout = 15000;
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(stmt => coreStatement = stmt, new GraphOptions().SetReadTimeoutMillis(defaultReadTimeout));
var session = _cluster.Connect();
const int readTimeout = 6000;
session.ExecuteGraph(new SimpleGraphStatement("g.V()").SetReadTimeoutMillis(readTimeout));
Assert.NotNull(coreStatement);
Assert.AreEqual(readTimeout, coreStatement.ReadTimeoutMillis);
Assert.True(coreStatement.OutgoingPayload.ContainsKey("request-timeout"));
Assert.That(coreStatement.OutgoingPayload["request-timeout"], Is.EqualTo(ExecuteGraphTests.ToBuffer(readTimeout)));
}
public void ExecuteGraph_Should_Allow_GraphNode_As_Parameters()
{
SimpleStatement coreStatement = null;
_cluster = ExecuteGraphTests.GetCluster(stmt => coreStatement = stmt);
var session = _cluster.Connect();
const string expectedJson =
"{\"member_id\":123,\"community_id\":586910,\"~label\":\"vertex\",\"group_id\":2}";
var id = new GraphNode("{\"result\":" + expectedJson + "}");
session.ExecuteGraph(new SimpleGraphStatement("g.V(vertexId)", new { vertexId = id }));
Assert.NotNull(coreStatement);
Assert.AreEqual(1, coreStatement.QueryValues.Length);
Assert.AreEqual("{\"vertexId\":" + expectedJson + "}", coreStatement.QueryValues[0]);
}
public override void Init(int flowCount, long flowRecordCount)
{
ConnectionString = ConnectionString == null ? "localhost" : ConnectionString;
sessions = new ISession[flowCount];
cluster = Cluster.Builder().AddContactPoint(ConnectionString).Build();
ISession session = cluster.Connect();
session.DeleteKeyspaceIfExists(KeySpace);
session.CreateKeyspace(KeySpace);
session.ChangeKeyspace(KeySpace);
sessions[0] = session;
for (int i = 0; i < flowCount; i++)
{
session = cluster.Connect();
session.ChangeKeyspace(KeySpace);
sessions[i] = session;
}
sessions[0].Execute(GetCreateTableQuery(CollectionName));
if (ConnectionString == "localhost")
DataDirectory = Path.Combine(GetConfigFilePath(), "data\\data");
}
