public WriterPropertiesBuilder CompressionLevel(ColumnPath path, int compressionLevel)
{
ExceptionInfo.Check(WriterPropertiesBuilder_Compression_Level_By_ColumnPath(_handle.IntPtr, path.Handle.IntPtr, compressionLevel));
GC.KeepAlive(_handle);
GC.KeepAlive(path);
return(this);
}
public override Void Execute()
{
var path = new ColumnPath {
Column_family = ColumnFamily.FamilyName
};
if (SuperColumnName != null)
{
path.Super_column = SuperColumnName;
}
if (ColumnName != null)
{
path.Column = ColumnName;
}
CassandraSession.Current.GetClient().remove(
Key,
path,
DateTimeOffset.Now.ToTimestamp(),
CassandraSession.Current.WriteConsistency
);
return(new Void());
}
public void InsertGetRemove()
{
var cp = new ColumnPath("Standard1", null, "InsertGetRemove");
// insert values
for (int i = 0; i < 100; i++)
{
Keyspace.Insert("InsertGetRemove." + i, cp, "InsertGetRemove.Value." + i);
}
// get values
for (int i = 0; i < 100; i++)
{
var column = Keyspace.GetColumn("InsertGetRemove." + i, cp);
Assert.NotNull(column);
Assert.Equal("InsertGetRemove.Value." + i, column.Value);
}
// remove values
for (int i = 0; i < 100; i++)
{
Keyspace.Remove("InsertGetRemove." + i, cp);
}
// make sure they are deleted
for (int i = 0; i < 100; i++)
{
Assert.Throws <NotFoundException>(() =>
{
Keyspace.GetColumn("InsertGetRemove." + i, cp);
});
}
}
public void MultigetColumn()
{
// insert
var columnPath = new ColumnPath("Standard1", null, "MultigetColumn");
var keys = new List <string>();
for (int i = 0; i < 100; i++)
{
var key = "MultigetColumn." + i;
Keyspace.Insert(key, columnPath, "MultigetColumn.value." + i);
keys.Add(key);
}
// get
var ms = Keyspace.MultigetColumn(keys, columnPath);
for (int i = 0; i < 100; i++)
{
var column = ms[keys[i]];
Assert.NotNull(column);
Assert.Equal("MultigetColumn.value." + i, column.Value);
}
// remove
for (int i = 0; i < 100; i++)
{
Keyspace.Remove("MultigetColumn." + i, columnPath);
}
}
public WriterPropertiesBuilder DisableDictionary(ColumnPath path)
{
ExceptionInfo.Check(WriterPropertiesBuilder_Disable_Dictionary_By_ColumnPath(_handle.IntPtr, path.Handle.IntPtr));
GC.KeepAlive(_handle);
GC.KeepAlive(path);
return(this);
}
public void GetSuperColumn()
{
var scmap = new Dictionary <string, IList <SuperColumn> >();
var list = new List <Column>();
for (int i = 0; i < 10; i++)
{
list.Add(new Column("GetSuperColumn." + i, "GetSuperColumn.Value." + i));
}
var superList = new List <SuperColumn> {
new SuperColumn("SuperColumn.1", list)
};
scmap.Add("Super1", superList);
Keyspace.BatchInsert("GetSuperColumn.1", null, scmap);
var columnPath = new ColumnPath("Super1", "SuperColumn.1", null);
try
{
var superColumn = Keyspace.GetSuperColumn("GetSuperColumn.1", columnPath);
Assert.NotNull(superColumn);
Assert.NotNull(superColumn.Columns);
Assert.Equal(10, superColumn.Columns.Count);
}
finally
{
Keyspace.Remove("GetSuperColumn.1", columnPath);
}
}
public void GetSuperRangeSlice()
{
for (int i = 0; i < 10; i++)
{
var cp = new ColumnPath("Super1", "SuperColumn.1", "GetSuperRangeSlice." + i);
Keyspace.Insert("GetSuperRangeSlice.0", cp, "GetSuperRangeSlice_value_" + i);
Keyspace.Insert("GetSuperRangeSlice.1", cp, "GetSuperRangeSlice_value_" + i);
}
var columnParent = new ColumnParent("Super1");
var predicate = new SlicePredicate(null, new SliceRange(false, 150));
var keySlices = Keyspace.GetSuperRangeSlice(columnParent, predicate, "GetSuperRangeSlice.0", "GetSuperRangeSlice.3", 5);
Assert.NotNull(keySlices);
Assert.Equal(2, keySlices.Where(x => x.Key.StartsWith("GetSuperRangeSlice.")).Count());
Assert.NotNull(keySlices["GetSuperRangeSlice.0"]);
Assert.Equal("GetSuperRangeSlice_value_0",
keySlices["GetSuperRangeSlice.0"].First().Columns.First().Value);
Assert.Equal(1, keySlices["GetSuperRangeSlice.1"].Count);
Assert.Equal(10, keySlices["GetSuperRangeSlice.1"].First().Columns.Count);
var columnPath = new ColumnPath("Super1");
for (int i = 0; i < 2; i++)
{
Keyspace.Remove("GetSuperRangeSlice" + i, columnPath);
}
}
public void GetRangeSlice()
{
env.RestartCassandra();
env.OpenConnection();
// build 3 keys with 10 columns each
for (int i = 0; i < 10; i++)
{
var cp = new ColumnPath("Standard2", null, "c" + i);
Insert("rs0", "v" + i, cp);
Insert("rs1", "v" + i, cp);
Insert("rs2", "v" + i, cp);
}
var columnParent = new ColumnParent("Standard2");
var predicate = new SlicePredicate(new SliceRange(false, 150));
var keySlices = client.get_range_slice(
"Keyspace1", columnParent, predicate,
"rs0", "rs3", 5, ConsistencyLevel.ONE);
Assert.NotNull(keySlices);
Assert.Equal(3, keySlices.Count);
Assert.NotNull(keySlices[0]);
Assert.Equal("v0", keySlices[0].Columns[0].Column.Value.UTFDecode());
Assert.Equal(10, keySlices[1].Columns.Count);
env.CloseConnection();
env.StopCassandra();
}
public void GetRangeSlice()
{
// build 3 keys with 10 columns each
for (int i = 0; i < 10; i++)
{
var cp = new ColumnPath("Standard2", null, "c" + i);
Keyspace.Insert("rs0", cp, "v" + i);
Keyspace.Insert("rs1", cp, "v" + i);
Keyspace.Insert("rs2", cp, "v" + i);
}
var columnParent = new ColumnParent("Standard2");
var predicate = new SlicePredicate(new SliceRange(false, 150));
var keySlices = Keyspace.GetRangeSlice(columnParent, predicate, "rs0", "rs3", 5);
Assert.NotNull(keySlices);
Assert.Equal(3, keySlices.Count);
Assert.NotNull(keySlices["rs0"]);
Assert.Equal("v0", keySlices["rs0"].First().Value);
Assert.Equal(10, keySlices["rs1"].Count);
var columnPath = new ColumnPath("Standard2");
for (int i = 0; i < 3; i++)
{
Keyspace.Remove("rs" + i, columnPath);
}
}
public WriterPropertiesBuilder EnableStatistics(ColumnPath path)
{
ExceptionInfo.Check(WriterPropertiesBuilder_Enable_Statistics_By_ColumnPath(_handle.IntPtr, path.Handle.IntPtr));
GC.KeepAlive(_handle);
GC.KeepAlive(path);
return(this);
}
/// <summary>
/// Reads data from storage
/// </summary>
/// <param name="key">Key which identifies the data</param>
/// <returns>Storage data</returns>
public object Value(Guid key)
{
// Get statement
byte[] keyEncoded = key.ToByteArray();
ColumnPath columnPath = new ColumnPath()
{
Column = ByteEncoderHelper.UTF8Encoder.ToByteArray("Value"),
Column_family = columnFamily,
};
ColumnOrSuperColumn column = (ColumnOrSuperColumn)cluster.Execute(new ExecutionBlock(delegate(Cassandra.Client client)
{
return(client.get(keyEncoded, columnPath, ConsistencyLevel.ONE));
}), keySpace);
var data = column.Column.Value;
using (MemoryStream ms = new MemoryStream(data))
{
using (BinaryReader br = new BinaryReader(ms))
{
return(Serializer.Deserialize(br));
}
}
}
static void Main(string[] args)
{
//建立数据库连接
TTransport transport = new TSocket("192.168.10.2", 9160);
TProtocol protocol = new TBinaryProtocol(transport);
Cassandra.Client client = new Cassandra.Client(protocol);
transport.Open();
System.Text.Encoding utf8Encoding = System.Text.Encoding.UTF8;
long timeStamp = DateTime.Now.Millisecond;
ColumnPath nameColumnPath = new ColumnPath()
{
Column_family = "Standard1",
Column = utf8Encoding.GetBytes("age")
};
//写入数据
client.insert("Keyspace1",
"studentA",
nameColumnPath,
utf8Encoding.GetBytes("18"),
timeStamp,
ConsistencyLevel.ONE);
//读取数据
ColumnOrSuperColumn returnedColumn = client.get("Keyspace1", "studentA", nameColumnPath, ConsistencyLevel.ONE);
Console.WriteLine("Keyspace1/Standard1: age: {0}, value: {1}", utf8Encoding.GetString(returnedColumn.Column.Name), utf8Encoding.GetString(returnedColumn.Column.Value));
//关闭连接
transport.Close();
}
public void MultigetSlice()
{
// insert
var columnPath = new ColumnPath("Standard1", null, "MultigetSlice");
var keys = new List <string>();
for (int i = 0; i < 100; i++)
{
var key = "MultigetSlice." + i;
Keyspace.Insert(key, columnPath, "MultigetSlice.value." + i);
keys.Add(key);
}
// get
var columnParent = new ColumnParent("Standard1");
var sliceRange = new SliceRange(false, 150);
var slicePredicate = new SlicePredicate(null, sliceRange);
var ms = Keyspace.MultigetSlice(keys, columnParent, slicePredicate);
for (int i = 0; i < 100; i++)
{
var columns = ms[keys[i]];
Assert.NotNull(columns);
Assert.Equal(1, columns.Count);
Assert.True(columns.First().Value.StartsWith("MultigetSlice."));
}
// remove
for (int i = 0; i < 100; i++)
{
Keyspace.Remove("MultigetSlice." + i, columnPath);
}
}
public WriterPropertiesBuilder Encoding(ColumnPath path, Encoding encoding)
{
ExceptionInfo.Check(WriterPropertiesBuilder_Encoding_By_ColumnPath(_handle.IntPtr, path.Handle.IntPtr, encoding));
GC.KeepAlive(_handle);
GC.KeepAlive(path);
return(this);
}
public void deleteRow(string keyspace, Object columnFamily, Object key)
{
client.set_keyspace(keyspace);
ColumnPath columnPath = new ColumnPath();
columnPath.Column_family = columnFamily.ToString();
client.remove(key.ToByteArray(), columnPath, createTimestamp(), consistencyLevel);
}
public void SimpleScenario()
{
env.RestartCassandra();
env.OpenConnection();
//At this point we're using the standard configuration file
var cp = new ColumnPath("Standard1", null, "name");
Console.WriteLine("Inserting a column");
Insert("1", "Josh Blogs", cp);
Insert("2", "Something else", cp);
//Let's get something back out (this is our select statement)
var returnedColumn = client.get(
"Keyspace1", //The database
"1", //The actual key we want
cp, //Where that key sits
ConsistencyLevel.ONE //HAZY
);
Console.WriteLine("We got Name: {0}, value {1}",
returnedColumn.Column.Name.UTFDecode(),
returnedColumn.Column.Value.UTFDecode());
Console.WriteLine("Now let's try getting a range");
//This is telling us the offest to get. This is where paging would occur.
var predicate = new SlicePredicate(new SliceRange(false, 10));
var parent = new ColumnParent("Standard1");
var keyedResults =
client.multiget_slice("Keyspace1",
new List <string> {
"1", "2"
},
parent,
predicate,
ConsistencyLevel.ONE);
foreach (var keyedResult in keyedResults)
{
Console.WriteLine("Key: {0}", keyedResult.Key);
foreach (ColumnOrSuperColumn result in keyedResult.Value)
{
Column column = result.Column;
Console.WriteLine("Name: {0}, value: {1}",
column.Name.UTFDecode(),
column.Value.UTFDecode());
}
}
env.CloseConnection();
env.StopCassandra();
}
public string this[int index] // It returns values that are shown in grid columns
{
get
{
object cell = Offset;
if (GridView.ShowPaths) // Use stored paths
{
ColumnPath path = GridView.Paths[index];
int ofs;
for (int i = 0; i < path.Segments.Count; i++)
{
ofs = (int)cell; // Use output as an input for the next iteration
if (path.Segments[i].GetData().IsNull(ofs))
{
cell = null;
break; // Cannot continue with next segments
}
else
{
cell = path.Segments[i].GetData().GetValue(ofs);
}
}
}
else // Use greater dimensions
{
int dimCount = GridView.Set.Columns.Count;
if (index < 0 || index >= dimCount)
{
return(null);
}
DcColumn dim = GridView.Set.Columns[index];
if (dim.GetData().IsNull(Offset))
{
cell = null;
}
else
{
cell = dim.GetData().GetValue(Offset);
}
}
if (cell == null)
{
return("");
}
else
{
return(Convert.ToString(cell));
}
}
}
protected ColumnPath BuildColumnPath(byte[] column)
{
var columnPath = new ColumnPath {
Column_family = columnFamily
};
if (column != null)
{
columnPath.Column = column;
}
return(columnPath);
}
public NColumn <N, V> getColumn <N, V>(string keyspace, Object columnFamily, Object key, N columnName)
{
client.set_keyspace(keyspace);
byte[] binaryKey = key.ToByteArray();
ColumnPath cp = new ColumnPath();
cp.Column_family = columnFamily.ToString();
cp.Column = columnName.ToByteArray();
var result = ThriftUtility.ToNColumn <N, V>(client.get(binaryKey, cp, consistencyLevel).Column);
return(result);
}
public void MultigetSuperSlice_With_SuperColumn()
{
var list = new List <Column>();
for (int i = 0; i < 10; i++)
{
list.Add(new Column("MultigetSuperSlice." + i, "MultigetSuperSlice.value." + i));
}
var scmap = new Dictionary <string, IList <SuperColumn> >();
scmap.Add("Super1", new List <SuperColumn>
{
new SuperColumn("SuperColumn.1", list),
new SuperColumn("SuperColumn.2", list),
});
var keys = new List <string>();
for (int i = 1; i <= 3; i++)
{
var key = "MultigetSuperSlice." + i;
Keyspace.BatchInsert(key, null, scmap);
keys.Add(key);
}
try
{
var columnParent = new ColumnParent("Super1", "SuperColumn.1");
var predicate = new SlicePredicate(null, new SliceRange(false, 150));
var superc = Keyspace.MultigetSuperSlice(keys, columnParent, predicate);
Assert.NotNull(superc);
Assert.Equal(3, superc.Count);
var scls = superc[keys[0]];
Assert.NotNull(scls);
Assert.Equal(1, scls.Count);
Assert.NotNull(scls[0].Columns);
Assert.Equal(10, scls[0].Columns.Count);
Assert.NotNull(scls[0].Columns[0].Value);
}
finally
{
var columnPath = new ColumnPath("Super1");
for (int i = 1; i <= 3; i++)
{
Keyspace.Remove("MultigetSuperSlice." + i, columnPath);
}
}
}
public static void TestDotRepresentations()
{
using var p0 = new ColumnPath("root.part0.part1");
using var p1 = new ColumnPath(new[] { "root", "part0", "part1" });
Assert.AreEqual("root.part0.part1", p0.ToDotString());
Assert.AreEqual("root.part0.part1", p1.ToDotString());
Assert.AreEqual(new[] { "root", "part0", "part1" }, p0.ToDotVector());
Assert.AreEqual(new[] { "root", "part0", "part1" }, p1.ToDotVector());
using var p2 = p0.Extend("part2");
Assert.AreEqual("root.part0.part1.part2", p2.ToDotString());
}
public override Void Execute(BaseCassandraColumnFamily columnFamily)
{
var path = new ColumnPath {
Column_family = columnFamily.FamilyName
};
CassandraSession.Current.GetClient().remove(
Key,
path,
DateTimeOffset.UtcNow.ToTimestamp(),
CassandraSession.Current.WriteConsistency
);
return(new Void());
}
/// <summary>
/// Best target for the current source.
/// </summary>
public void SelectBestTarget()
{
ColumnPath sourcePath = SourceTree.SelectedPath;
if (sourcePath == null)
{
return; // Primary node is not selected
}
if (!sourcePath.IsPrimitive)
{
return; // Only primitive paths can be matchd
}
ColumnPath pargetPath = mapper.MapCol(sourcePath, TargetTab); // Find best path starting from the target set and corresponding to the source path
TargetTree.SelectedPath = pargetPath;
}
public static void TestDotRepresentationsUtf8()
{
const string part1 = "2H₂ + O₂ ⇌ 2H₂O, R = 47 kΩ, ⌀ 200 mm";
using var p0 = new ColumnPath("root.part0." + part1);
using var p1 = new ColumnPath(new[] { "root", "part0", part1 });
Assert.AreEqual("root.part0." + part1, p0.ToDotString());
Assert.AreEqual("root.part0." + part1, p1.ToDotString());
Assert.AreEqual(new[] { "root", "part0", part1 }, p0.ToDotVector());
Assert.AreEqual(new[] { "root", "part0", part1 }, p1.ToDotVector());
using var p2 = p0.Extend("α ∧ ¬β");
Assert.AreEqual("root.part0." + part1 + ".α ∧ ¬β", p2.ToDotString());
}
/// <summary>
/// Removes data from storage
/// </summary>
/// <param name="key">Key which identifies the data</param>
/// <returns>True if data was present in the storage</returns>
public bool Remove(Guid key)
{
// Get statement
byte[] keyEncoded = key.ToByteArray();
ColumnPath columnPath = new ColumnPath()
{
Column = ByteEncoderHelper.UTF8Encoder.ToByteArray("Value"),
Column_family = columnFamily,
};
cluster.Execute(new ExecutionBlock(delegate(Cassandra.Client client)
{
client.remove(keyEncoded, columnPath, UnixHelper.UnixTimestamp, ConsistencyLevel.ONE);
return(null);
}), keySpace);
return(true);
}
public static double ComputePathSimilarity(ColumnPath source, ColumnPath target)
{
if (source == null || target == null || source.Size == 0 || target.Size == 0)
{
return(0);
}
double rankFactor1 = 0.5;
double rankFactor2 = 0.5;
double sumCol = 0.0;
double sumTab = 0.0;
double w1 = 1.0;
for (int i = source.Segments.Count - 1; i >= 0; i--)
{
string d1 = source.Segments[i].Name;
string s1 = source.Segments[i].Output.Name;
double w2 = 1.0;
for (int j = target.Segments.Count - 1; j >= 0; j--)
{
string d2 = target.Segments[j].Name;
string s2 = target.Segments[j].Output.Name;
double simCol = ComputeStringSimilarity(d1, d2, 3);
simCol *= (w1 * w2);
sumCol += simCol;
double simTab = ComputeStringSimilarity(s1, s2, 3);
simTab *= (w1 * w2);
sumTab += simTab;
w2 *= rankFactor1; // Decrease the weight
}
w1 *= rankFactor2; // Decrease the weight
}
sumCol /= (source.Segments.Count * target.Segments.Count);
sumTab /= (source.Segments.Count * target.Segments.Count);
return((sumCol + sumTab) / 2);
}
public override IFluentSuperColumn <CompareWith, CompareSubcolumnWith> Execute(BaseCassandraColumnFamily columnFamily)
{
var path = new ColumnPath {
Column_family = columnFamily.FamilyName
};
if (SuperColumnName != null)
{
path.Super_column = SuperColumnName;
}
var output = CassandraSession.Current.GetClient().get(
Key,
path,
CassandraSession.Current.ReadConsistency
);
return((IFluentSuperColumn <CompareWith, CompareSubcolumnWith>)Helper.ConvertToFluentBaseColumn <CompareWith, CompareSubcolumnWith>(output));
}
public static void TestNodeRepresentation()
{
var columns = new Column[] { new Column <int[]>("value") };
using var schema = Column.CreateSchemaNode(columns);
using var p0 = new ColumnPath(schema);
using var p1 = new ColumnPath(schema.Field(0));
using var p2 = new ColumnPath(((GroupNode)schema.Field(0)).Field(0));
using var p3 = new ColumnPath(((GroupNode)((GroupNode)schema.Field(0)).Field(0)).Field(0));
Assert.AreEqual("", p0.ToDotString());
Assert.AreEqual("value", p1.ToDotString());
Assert.AreEqual("value.list", p2.ToDotString());
Assert.AreEqual("value.list.item", p3.ToDotString());
Assert.AreEqual("", schema.Path.ToDotString());
Assert.AreEqual("value", schema.Field(0).Path.ToDotString());
Assert.AreEqual("value.list", ((GroupNode)schema.Field(0)).Field(0).Path.ToDotString());
Assert.AreEqual("value.list.item", ((GroupNode)((GroupNode)schema.Field(0)).Field(0)).Field(0).Path.ToDotString());
}
/// <summary>
/// Secondary: Enabled/disabled status of a secondary node. Whether the current paths can be added as a new match without contradiction to the existing matches.
/// Secondary: given a primary currently selected node, compute if a match with this secondary node does not contradict to existing matches (so it can be added). Alternatively, if relevances are precomputed then we find if relevance is higher than 0.
/// Primary: always true (if there is at least one possible secondary match).
/// </summary>
public bool CanMatchTarget(ColumnPath path)
{
if (TargetTree.IsPrimary)
{
return(true);
}
else
{
ColumnPath priPath = SourceTree.SelectedPath;
if (priPath == null)
{
return(false); // Primary node is not selected
}
if (!priPath.IsPrimitive || !path.IsPrimitive)
{
return(false); // Only primitive paths can be matchd
}
return(true);
}
}
public void ValidateColumnPath()
{
var cp = new ColumnPath("Standard1", null, "ValidateColumnPath");
Keyspace.Insert("ValidateColumnPath", cp, "ValidateColumnPath Value");
Keyspace.Remove("ValidateColumnPath", cp);
cp = new ColumnPath("CFDoesNotExist", null, "TestInsertGetRemove");
Assert.Throws <InvalidRequestException>(() =>
{
Keyspace.Insert("ValidateColumnPath", cp, "testValidColumnPath_value");
});
cp = new ColumnPath("Standard1", "TestInsertGetRemove", null);
Assert.Throws <InvalidRequestException>(() =>
{
Keyspace.Insert("ValidateColumnPath", cp, "testValidColumnPath_value");
});
}
//throws InvalidRequestException
/// <summary>
///Make sure that the given column path is a SuperColumn in the DB, Throws an exception if it's not.
/// </summary>
/// <param name="columnPath"></param>
void AssertSuperColumnPath(ColumnPath columnPath)
{
var cf = columnPath.ColumnFamily;
IDictionary<string, string> cfdefine;
if ((cfdefine = Description[cf]) != null
&& cfdefine[CF_TYPE].Equals(CF_TYPE_SUPER)
&& columnPath.SuperColumn != null)
{
return;
}
throw new InvalidRequestException(
"Invalid super column or super column family does not exist: " + cf, null);
}
//throws InvalidRequestException
/// <summary>
/// Make sure that if the given column path was a Column. Throws an InvalidRequestException if not.
/// </summary>
/// <param name="columnPath">if either the column family does not exist or that it's type does not match (super)..</param>
void AssertColumnPath(ColumnPath columnPath)
{
string cf = columnPath.ColumnFamily;
IDictionary<string, string> cfdefine;
if (!Description.ContainsKey(cf))
throw new InvalidRequestException("The specified column family does not exist: " + cf, null);
cfdefine = Description[cf];
if (cfdefine[CF_TYPE].Equals(CF_TYPE_STANDARD) && columnPath.Column != null)
return; // if the column family is a standard column
else if (cfdefine[CF_TYPE].Equals(CF_TYPE_SUPER) && columnPath.SuperColumn != null && columnPath.Column != null)
// if the column family is a super column and also give the super_column name
return;
}
public void Failover()
{
var h1client = new Mock<ICassandraClient>();
var h2client = new Mock<ICassandraClient>();
var h3client = new Mock<ICassandraClient>();
var h1endpoint = new Endpoint("h1", 111, "ip1");
var h2endpoint = new Endpoint("h2", 111, "ip2");
var h3endpoint = new Endpoint("h3", 111, "ip3");
var tprotocol = new Mock<TProtocol>(new Mock<TTransport>().Object);
var h1cassandra = new Mock<Apache.Cassandra.Cassandra.Client>(tprotocol.Object).As<Apache.Cassandra.Cassandra.Iface>();
var h2cassandra = new Mock<Apache.Cassandra.Cassandra.Client>(tprotocol.Object).As<Apache.Cassandra.Cassandra.Iface>();
var h3cassandra = new Mock<Apache.Cassandra.Cassandra.Client>(tprotocol.Object).As<Apache.Cassandra.Cassandra.Iface>();
var keyspaceName = "Keyspace1";
var description = new Dictionary<string, Dictionary<string, string>>();
var keyspace1desc = new Dictionary<string, string>();
keyspace1desc.Add(HectorSharp.Keyspace.CF_TYPE, HectorSharp.Keyspace.CF_TYPE_STANDARD);
description.Add("Standard1", keyspace1desc);
var consistencyLevel = HectorSharp.ConsistencyLevel.ONE;
var cp = new ColumnPath("Standard1", null, "Failover");
var pool = new Mock<IKeyedObjectPool<Endpoint, ICassandraClient>>();
var monitor = new Mock<ICassandraClientMonitor>();
// list of available servers
var tokenMap = new Dictionary<string, string>();
tokenMap.Add("t1", "h1");
tokenMap.Add("t2", "h2");
tokenMap.Add("t3", "h3");
h1client.Setup(c => c.Client).Returns(h1cassandra.Object);
h2client.Setup(c => c.Client).Returns(h2cassandra.Object);
h3client.Setup(c => c.Client).Returns(h3cassandra.Object);
h1client.Setup(c => c.Port).Returns(h1endpoint.Port);
h2client.Setup(c => c.Port).Returns(h2endpoint.Port);
h3client.Setup(c => c.Port).Returns(h3endpoint.Port);
h1client.Setup(c => c.GetTokenMap(AnyBool())).Returns(tokenMap);
h2client.Setup(c => c.GetTokenMap(AnyBool())).Returns(tokenMap);
h3client.Setup(c => c.GetTokenMap(AnyBool())).Returns(tokenMap);
h1client.Setup(c => c.Endpoint).Returns(h1endpoint);
h2client.Setup(c => c.Endpoint).Returns(h2endpoint);
h3client.Setup(c => c.Endpoint).Returns(h3endpoint);
pool.Setup(p => p.Borrow(IsEndpoint(h1endpoint))).Returns(h1client.Object);
pool.Setup(p => p.Borrow(IsEndpoint(h2endpoint))).Returns(h2client.Object);
pool.Setup(p => p.Borrow(IsEndpoint(h3endpoint))).Returns(h3client.Object);
// success without failover
var failoverPolicy = new FailoverPolicy(0, FailoverStrategy.FAIL_FAST);
var ks = new Keyspace(h1client.Object, keyspaceName, description, consistencyLevel, failoverPolicy, pool.Object, monitor.Object);
ks.Insert("key", cp, "value");
// fail fast
h1cassandra.Setup(
c => c.insert(AnyString(), AnyString(), Any<Apache.Cassandra.ColumnPath>(), AnyBytes(), AnyLong(), Any<Apache.Cassandra.ConsistencyLevel>()))
.Throws(new Apache.Cassandra.TimedOutException());
Assert.Throws<TimedOutException>(() => ks.Insert("key", cp, "value"));
// on fail try next one, h1 fails, h2 succeeds
failoverPolicy = new FailoverPolicy(3, FailoverStrategy.ON_FAIL_TRY_ONE_NEXT_AVAILABLE);
ks = new Keyspace(h1client.Object, keyspaceName, description, consistencyLevel, failoverPolicy, pool.Object, monitor.Object);
ks.Insert("key", cp, "value");
h2cassandra.Verify(
c => c.insert(AnyString(), AnyString(), Any<Apache.Cassandra.ColumnPath>(), AnyBytes(), AnyLong(), Any<Apache.Cassandra.ConsistencyLevel>())
);
pool.Verify(p => p.Borrow(IsEndpoint(h2endpoint)));
// make all nodes fail
h2cassandra.Setup(
c => c.insert(AnyString(), AnyString(), Any<Apache.Cassandra.ColumnPath>(), AnyBytes(), AnyLong(), Any<Apache.Cassandra.ConsistencyLevel>()))
.Throws(new Apache.Cassandra.TimedOutException());
h3cassandra.Setup(
c => c.insert(AnyString(), AnyString(), Any<Apache.Cassandra.ColumnPath>(), AnyBytes(), AnyLong(), Any<Apache.Cassandra.ConsistencyLevel>()))
.Throws(new Apache.Cassandra.TimedOutException());
ks = new Keyspace(h1client.Object, keyspaceName, description, consistencyLevel, failoverPolicy, pool.Object, monitor.Object);
Assert.Throws<TimedOutException>(() => ks.Insert("key", cp, "value"));
}
