//TotalStringKeyCount ==========================================================================================
public bool TotalStringKeyCount(ref long count)
{
lock (_object)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
var totalStringKeyCountAsync = _aClient.totalStringKeyCountAsync();
if (totalStringKeyCountAsync.IsFaulted || totalStringKeyCountAsync.IsCanceled)
{
Console.WriteLine("totalStringKeyCountAsync.IsFaulted");
count = 0;
clientInfo.cleanUp();
return(false);
}
count = totalStringKeyCountAsync.Result;
clientInfo.cleanUp();
return(true);
}
}
//BsRemoveKeyBs=================================================================================================
public bool BsRemoveKeyBs(string bsKey, ref long totalCount)
{
lock (_object)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
var removeAllAsync = _aClient.removeAllAsync(bsKey);
if (removeAllAsync.IsCanceled || removeAllAsync.IsFaulted)
{
clientInfo.cleanUp();
return(false);
}
totalCount = removeAllAsync.Result;
clientInfo.cleanUp();
return(true);
}
}
// BsRangeQueryByPage get >= startkey && <= endkey có chia page theo begin and end==============================
public bool BsRangeQueryByPage(string bsKey, string startItemKey, string endItemKey, long begin, long end,
ref TItemSetResult itemSetResult, ref long total)
{
lock (_object)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
byte[] BstartItemKey;
byte[] BendItemKey;
try
{
BstartItemKey = Encoding.UTF8.GetBytes(startItemKey);
BendItemKey = Encoding.UTF8.GetBytes(endItemKey);
}
catch (Exception e)
{
Console.WriteLine("error " + e.ToString());
clientInfo.cleanUp();
return(false);
}
var bsRangeQueryAsync = _aClient.bsRangeQueryAsync(bsKey, BstartItemKey, BendItemKey);
if (bsRangeQueryAsync.Result.Items.Items.Count < 1)
{
clientInfo.cleanUp();
return(false);
}
if (begin < 0)
{
begin = 0;
}
if (end > bsRangeQueryAsync.Result.Items.Items.Count)
{
end = bsRangeQueryAsync.Result.Items.Items.Count;
}
total = bsRangeQueryAsync.Result.Items.Items.Count;
itemSetResult.Items.Items.CopyTo(Convert.ToInt32(begin), bsRangeQueryAsync.Result.Items.Items.ToArray(), 0, Convert.ToInt32(end - begin));
clientInfo.cleanUp();
return(false);
}
}
// BsGetSliceByArray get by position begin -> end
public bool BsGetSliceByArray(string bsKey, int begin, int count, ref TItemSetResult itemSetResult)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
var bsGetSliceRAsync = _aClient.bsGetSliceRAsync(bsKey, begin, count);
if (bsGetSliceRAsync.IsCanceled || bsGetSliceRAsync.IsFaulted)
{
Console.WriteLine("bsGetSliceRAsync.IsCanceled || bsGetSliceRAsync.IsFaulted");
clientInfo.cleanUp();
return(false);
}
if (bsGetSliceRAsync.Result.Items.Items.Count < 1)
{
clientInfo.cleanUp();
return(false);
}
itemSetResult = bsGetSliceRAsync.Result;
clientInfo.cleanUp();
return(true);
}
// BsRangeQuery get >= startkey && <= endkey
public bool BsRangeQuery(string bsKey, string startItemKey, string endItemKey, ref TItemSetResult itemSetResult)
{
lock (_object)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
byte[] BstartItemKey;
byte[] BendItemKey;
try
{
BstartItemKey = Encoding.UTF8.GetBytes(startItemKey);
BendItemKey = Encoding.UTF8.GetBytes(endItemKey);
}
catch (Exception e)
{
Console.WriteLine("error " + e.ToString());
clientInfo.cleanUp();
return(false);
}
var bsRangeQueryAsync = _aClient.bsRangeQueryAsync(bsKey, BstartItemKey, BendItemKey);
if (bsRangeQueryAsync.IsCanceled || bsRangeQueryAsync.IsFaulted)
{
Console.WriteLine("bsRangeQueryAsync.IsCanceled || bsRangeQueryAsync.IsFaulted");
clientInfo.cleanUp();
return(false);
}
itemSetResult = bsRangeQueryAsync.Result;
if (itemSetResult.Items.Items.Count < 1)
{
clientInfo.cleanUp();
return(false);
}
clientInfo.cleanUp();
return(true);
}
}
// BsGetSlice get all
public bool BsGetSlice(string bsKey, ref TItemSetResult itemSetResult)
{
lock (_object){
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
var getTotalCountAsync = _aClient.getTotalCountAsync(bsKey);
if (getTotalCountAsync.IsCanceled || getTotalCountAsync.IsFaulted)
{
Console.WriteLine("getTotalCountAsync.IsCanceled || getTotalCountAsync.IsFaulted");
clientInfo.cleanUp();
return(false);
}
long totalCount = getTotalCountAsync.Result;
//Console.WriteLine("Count "+totalCount);
int count = Convert.ToInt32(totalCount);
if (count < 1)
{
clientInfo.cleanUp();
return(false);
}
var bsGetSliceRAsync = _aClient.bsGetSliceRAsync(bsKey, 0, count);
if (bsGetSliceRAsync.IsCanceled || bsGetSliceRAsync.IsFaulted)
{
Console.WriteLine("bsGetSliceRAsync.IsCanceled || bsGetSliceRAsync.IsFaulted");
clientInfo.cleanUp();
return(false);
}
itemSetResult = bsGetSliceRAsync.Result;
clientInfo.cleanUp();
return(true);
}
}
//CheckBsExisted================================================================================================
public bool CheckBsExisted(string bsKey, string itemKey)
{
lock (_object)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
byte[] bitemKey;
try
{
bitemKey = Encoding.UTF8.GetBytes(itemKey);
}
catch (Exception e)
{
Console.WriteLine(e);
clientInfo.cleanUp();
return(false);
}
var bsExistedAsyncs = _aClient.bsExistedAsync(bsKey, bitemKey);
if (bsExistedAsyncs.IsCanceled || bsExistedAsyncs.IsFaulted)
{
Console.WriteLine("bsExistedAsyncs.IsFaulted");
clientInfo.cleanUp();
return(false);
}
clientInfo.cleanUp();
return(bsExistedAsyncs.Result.Existed);
}
}
//g// GetTotalCount return number item of bskey
public bool GetTotalCount(string bsKey, ref long count)
{
lock (_object)
{
count = 0;
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
var getTotalCountAsync = _aClient.getTotalCountAsync(bsKey);
if (getTotalCountAsync.IsFaulted || getTotalCountAsync.IsCanceled)
{
Console.WriteLine("getTotalCountAsync.IsFaulted");
clientInfo.cleanUp();
return(false);
}
long totalCount = getTotalCountAsync.Result;
if (totalCount < 1)
{
clientInfo.cleanUp();
return(false);
}
count = totalCount;
clientInfo.cleanUp();
return(true);
}
}
// BsGetItem get item by bskey and itemkey
public bool BsGetItem(string bsKey, string key, ref TItem item)
{
lock (_object)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
var bsGetItemAsync = _aClient.bsGetItemAsync(bsKey, Encoding.ASCII.GetBytes(key));
if (bsGetItemAsync.IsCanceled || bsGetItemAsync.IsCanceled)
{
clientInfo.cleanUp();
return(false);
}
if (bsGetItemAsync.Result.Item == null)
{
Console.WriteLine("Item not exists");
return(false);
}
item = bsGetItemAsync.Result.Item;
clientInfo.cleanUp();
return(true);
}
}
public bool BsgMultiPutItem(string[] keys, TItem item)
{
lock (_object)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
foreach (var key in keys)
{
var bsPutItemAsync = _aClient.bsPutItemAsync(key, item);
if (bsPutItemAsync.IsCompleted == false)
{
bsPutItemAsync.Wait();
if (bsPutItemAsync.IsCompleted == false)
{
return(false);
}
}
}
clientInfo.cleanUp();
return(true);
}
}
//GetListKey ==================================================================================================
public bool GetListKey(long fromIndex, int count, List <String> listKey)
{
lock (_object)
{
TClientInfo clientInfo = _setClient.getClient();
if (!clientInfo.isOpen())
{
clientInfo.doOpen();
}
if (!clientInfo.sureOpen())
{
Thread.Sleep(1 * 100);
if (!clientInfo.sureOpen())
{
Console.WriteLine("Can't open");
return(false);
}
}
_aClient = (TStringBigSetKVService.Client)clientInfo.getClient();
var getListKeyAsync = _aClient.getListKeyAsync(fromIndex, count);
if (getListKeyAsync.IsCanceled || getListKeyAsync.IsFaulted)
{
Console.WriteLine("getListKeyAsync.IsCanceled || getListKeyAsync.IsFaulted");
clientInfo.cleanUp();
return(false);
}
if (getListKeyAsync.Result.Count < 1)
{
clientInfo.cleanUp();
return(false);
}
listKey = getListKeyAsync.Result;
clientInfo.cleanUp();
return(true);
}
}
public static void Main()
{
try
{
IPAddress ipaddress = IPAddress.Parse("127.0.0.1");
TTransport transport = new TSocketTransport(ipaddress, 18990, 100000);
TFramedTransport tFrameTransport = new TFramedTransport(transport);
TProtocol protocol = new TBinaryProtocol(tFrameTransport);
TStringBigSetKVService.Client client = new TStringBigSetKVService.Client(protocol);
client.OpenTransportAsync();
Console.WriteLine("transport.IsOpen");
Console.WriteLine(transport.IsOpen);
if (transport.IsOpen)
{
// Book book = new Book();
// book.Author = "Auth";
// book.Category = "Category";
// book.Id = "12123";
// book.Price = 10123;
// book.BookName = "Book Name";
//
// var bookJson = JsonConvert.SerializeObject(book);
// var bJson = Encoding.ASCII.GetBytes(bookJson);;
// var str = Encoding.UTF8.GetString(bJson);
// // Console.WriteLine(bJson);
// Console.WriteLine(str);
// var tItem = new TItem();
// tItem.Key = Encoding.ASCII.GetBytes(book.Id);
// tItem.Value = bJson;
//
// var bsPutItemAsync = client.bsPutItemAsync("Test", tItem);
// Console.WriteLine(bsPutItemAsync.IsCompleted);
// if (bsPutItemAsync.IsCompleted == false)
// {
// bsPutItemAsync.Wait();
// }
// // ========================
// var serializeObject = JsonConvert.SerializeObject(bsPutItemAsync);
// Console.WriteLine(serializeObject);
// Get data from thrift
var bsGetItemAsync = client.bsGetItemAsync("Test", Encoding.ASCII.GetBytes("12123"));
// bsGetItemAsync.Start();
// bsGetItemAsync.RunSynchronously();
Console.WriteLine("serializeObject: ");
Console.WriteLine(bsGetItemAsync.IsCanceled);
Console.WriteLine(bsGetItemAsync.IsFaulted);
Console.WriteLine(bsGetItemAsync.IsCompleted);
if (bsGetItemAsync.IsCompleted == false)
{
Console.WriteLine("bsGetItemAsync.IsCompleted == false");
bsGetItemAsync.Wait();
}
Console.WriteLine(bsGetItemAsync.IsCompletedSuccessfully);
Console.WriteLine(bsGetItemAsync.Status);
Console.WriteLine(bsGetItemAsync.Id);
// bsGetItemAsync.Wait();
Console.WriteLine(bsGetItemAsync.ToString());
// Console.WriteLine(bsGetItemAsync.Result.Item.Value);
var obj = Encoding.UTF8.GetString(bsGetItemAsync.Result.Item.Value);
Console.WriteLine(obj);
// ==========================
//
// int sum = client.add(1, 1);
// Console.WriteLine("1+1={0}", sum);
//
// Work work = new Work();
//
// work.Op = Operation.DIVIDE;
// work.Num1 = 1;
// work.Num2 = 0;
// try
// {
// int quotient = client.calculate(1, work);
// Console.WriteLine("Whoa we can divide by 0");
// }
// catch (InvalidOperation io)
// {
// Console.WriteLine("Invalid operation: " + io.Why);
// }
//
// work.Op = Operation.SUBTRACT;
// work.Num1 = 15;
// work.Num2 = 10;
// try
// {
// int diff = client.calculate(1, work);
// Console.WriteLine("15-10={0}", diff);
// }
// catch (InvalidOperation io)
// {
// Console.WriteLine("Invalid operation: " + io.Why);
// }
//
// SharedStruct log = client.getStruct(1);
// Console.WriteLine("Check log: {0}", log.Value);
}
}
catch (Exception e)
{
Console.WriteLine(e.Data);
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
