public int?GetImitateID(int characterId)
{
var possibleId = _db?.StringGet(GetImitateKeyName(characterId));
if (possibleId != null && int.TryParse(possibleId.Value, out int id))
{
return(id);
}
return(null);
}
public static void RedisConnectionAndUpload(string connectionString)
{
var muxer = ConnectionMultiplexer.Connect(configuration: connectionString);
conn = muxer.GetDatabase();
muxer.Wait(conn.PingAsync());
List<City> citys = CityDataSource.CityDataSource.GetCitys();
if (conn.StringGet("IsValue").IsNull)
{
int i = 0;
citys.Take(1000).ToList().ForEach(c =>
{
i++;
conn.HashSetAsync("Citys:Data:" + c.Id.ToString(), c.ToHashEntries());
List<string> prefix = GetPrefix(c.Name);
prefix.Concat(GetPrefix(c.Code));
if (!string.IsNullOrEmpty(c.Name))
conn.SortedSetAdd(key: "CityName", member: c.Name, score: 0);
if (!string.IsNullOrEmpty(c.Code))
conn.SortedSetAdd(key: "CityCode", member: c.Code, score: 0);
foreach (var p in prefix)
{
conn.SortedSetAdd("Citys:index:" + p, c.Id, 0);
}
});
conn.StringSet(key: "IsValue", value: true);
}
}
public static Dictionary<string,string> RedisConnectionAndUpload(string connectionString)
{
var dict = new Dictionary<string, string>()
ConnectionMultiplexer muxer = ConnectionMultiplexer.Connect(configuration: connectionString);
conn = muxer.GetDatabase();
muxer.Wait(conn.PingAsync());
List<City> citys = CityDataSource.CityDataSource.GetCitys();
if (conn.StringGet(key: "IsValue").IsNull)
{
var oneByone = new Stopwatch();
oneByone.Start();
int i = 0;
citys.ToList().ForEach(c =>
{
i++;
conn.HashSetAsync("Citys:Data:" + c.Id.ToString(), c.ToHashEntries());
List<string> prefix = GetPrefix(c.Name);
prefix.Concat(GetPrefix(c.Code));
if (!string.IsNullOrEmpty(c.Name))
conn.SortedSetAdd(key: "CityName", member: c.Name, score: 0);
if (!string.IsNullOrEmpty(c.Code))
conn.SortedSetAdd(key: "CityCode", member: c.Code, score: 0);
foreach (var p in prefix)
{
conn.SortedSetAdd("Citys:index:" + p, c.Id, 0);
}
});
oneByone.Stop();
dict.Add(key: "OneByOne Elapsed Milliseconds: ", value: oneByone.ElapsedMilliseconds.ToString());
dict.Add(key: "OneByOne Elapsed Seconds: ", value: (oneByone.ElapsedMilliseconds/1000).ToString());
var whole = new Stopwatch();
whole.Start();
conn.StringSet(key: "cityslist", value: Serialize(citys));
whole.Stop();
dict.Add(key: "Whole Elapsed Milliseconds: ", value: whole.ElapsedMilliseconds.ToString());
dict.Add(key: "whole Elapsed Seconds: ", value: (whole.ElapsedMilliseconds / 1000).ToString());
conn.StringSet(key: "IsValue", value: true);
}
return dict;
}
public static int CalculateFibonachiNumberRedisCache(int n, IDatabase cache)
{
var cacheKey = "fibo-cache" + n;
string cachedValue = cache?.StringGet(cacheKey);
if (!string.IsNullOrWhiteSpace(cachedValue) && int.TryParse(cachedValue, out int result))
{
return(result);
}
var calculationResult = CalculateFibonachiNumber(n);
cache?.StringSet(cacheKey, calculationResult);
return(calculationResult);
}
/// <summary>
/// 获取key缓存String类型数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T Get <T>(string key)
{
var result = JsonConvert.DeserializeObject <T>(_database.StringGet(key));
return(result);
}
/// <summary>
/// 获取单个对象
/// </summary>
/// <param name="Key"></param>
/// <returns></returns>
public string StringGet(string key)
{
key = AddSysCustomKey(key);
return(Database.StringGet(key));
}
public string Select(string key)
{
return(_db.StringGet(key));
}
private static void _SetAndGetStringCacheValue(IDatabase database)
{
database.StringSet(StringCacheKey, StringCacheValue);
var retrievedValue = database.StringGet(StringCacheKey);
Console.WriteLine($"Expected value = {StringCacheValue}, Retrieved value = {retrievedValue}");
}
public string Get([FromQuery] string key)
{
var value = _database.StringGet(key);
return(value);
}
private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker bgWorker = sender as BackgroundWorker;
string stamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
if (redis.IsConnected)
{
}
else
{
string content = " redis server is not connected";
this.AppendLog(content + stamp);
return;
}
try
{
IDatabase db = this.redis.GetDatabase(redisDbIndex);
List <RedisKey> keyCollection = new List <RedisKey>();
foreach (string key in list)
{
keyCollection.Add(key);
}
RedisKey[] keys = keyCollection.ToArray();
RedisValue[] vals = db.StringGet(keys);
foreach (RedisValue rv in vals)
{
if (!rv.IsNull)
{
DataValue dv = JsonConvert.DeserializeObject <DataValue>((string)rv);
string key = dv.SensorId + "-" + dv.ValueType;
if (globalStamp[key] != dv.TimeStamp)
{
string str = dv.SensorId + " " + dv.TimeStamp + " " + dv.ValueType + " " + dv.Value;
this.dataQueue.Enqueue(dv);
this.AppendLog(stamp + " " + str);
globalStamp[key] = dv.TimeStamp;
}
else
{
this.AppendLog(stamp + " " + key + " not updated");
}
}
}
}
catch (Exception ex)
{
using (StreamWriter sw = new StreamWriter(@"ErrLog.txt", true))
{
sw.WriteLine(ex.Message + " \r\n" + ex.StackTrace.ToString());
sw.WriteLine("---------------------------------------------------------");
sw.Close();
}
}
}
public byte[] GetData(string filename)
{
return(RedisCache.StringGet(filename));
}
public T ReadCache <T>(string key, int dbName)
{
try
{
IDatabase db = _redisMultiplexer.GetDatabase(dbName);
var data = db.KeyExists(key) == true?Newtonsoft.Json.JsonConvert.DeserializeObject <T>(db.StringGet(key).ToString()) : default(T);
return(data);
}
catch (Exception ex)
{
LogHelper.Error("ReadCache", ex, key);
Console.WriteLine(ex.ToString());
return(default(T));
}
}
public string Get(string key)
{
IDatabase db = redis.GetDatabase();
return(db.StringGet(key));
}
/// <summary>
/// 获取 一个简单的字符串键值
/// </summary>
/// <param name="key">键</param>
/// <returns>值</returns>
public RedisValue StringGet(string key)
{
return(_base.StringGet(key));
}
/// <summary>
/// 获取缓存用户票证信息
/// </summary>
/// <param name="userid">用户id</param>
/// <param name="versions">版本</param>
/// <returns></returns>
public static string GetSecretKeyCache(this IDatabase readis, string userid, string versions)
{
return(readis.StringGet("SecretKey_" + userid + versions.Replace(".", "")));
}
/// <summary>
/// 获取缓存
/// </summary>
public static string GetCache(this IDatabase readis, string key)
{
return(readis.StringGet(key));
}
//取值
private void button3_Click(object sender, EventArgs e)
{
this.textBox5.Text = _db.StringGet("test");
}
/// <summary>
/// 获取单个key的值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public string StringGet(string redisKey, TimeSpan?expiry = null)
{
redisKey = AddKeyPrefix(redisKey);
return(_db.StringGet(redisKey));
}
private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker bgWorker = sender as BackgroundWorker;
string stamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
string str = "";
str += stamp + " ";
if (redis.IsConnected)
{
}
else
{
str += "redis server is not connected";
//lthis.AppendLog(str);
return;
}
Dictionary <RedisKey, RedisValue> pair = new Dictionary <RedisKey, RedisValue>();
//string stamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
try
{
IDatabase db_raw = this.redis.GetDatabase(0);
IDatabase db_result = this.redis.GetDatabase(redisDbIndex);
//RedisKey[] keys = list.Keys.Select(key => (RedisKey)key).ToArray();
List <RedisKey> keyCollection = new List <RedisKey>();
foreach (string k in list.Keys)
{
keyCollection.Add(k);
//keyCollection.Add(k + "-005");
//keyCollection.Add(k + "-012");
}
RedisKey[] keys = keyCollection.ToArray();
RedisValue[] vals = db_raw.StringGet(keys);
Dictionary <string, DataValue> dvs = new Dictionary <string, DataValue>();
foreach (RedisValue rv in vals)
{
if (!rv.IsNull)
{
Bgk_Micro_40A_Data dv = JsonConvert.DeserializeObject <Bgk_Micro_40A_Data>((string)rv);
string key = dv.SensorId;
double temp = ResistanceToTemperature(dv.Value2);
BgkStrainConfig ptv = list[key];
if (ptv.Stamp != dv.TimeStamp)
{
ptv.isUpdated = true;
ptv.temperature = temp;
ptv.frequency = dv.Value1;
ptv.Stamp = dv.TimeStamp;
}
}
}
foreach (string key in list.Keys)
{
//string str = "";
BgkStrainConfig ptv = list[key];
if (ptv.isUpdated)
{
if (ptv.temperature == 0 || ptv.frequency == 0)
{
this.AppendLog(stamp + " " + ptv.SensorId + "This Channel is broken");
continue;
}
string strainNormalKey = ptv.SensorId + "-009";
double strain = CalculateStrain(ptv);
DataValue strainDv = new DataValue();
strainDv.SensorId = ptv.SensorId;
strainDv.TimeStamp = ptv.Stamp;
strainDv.ValueType = "009";
strainDv.Value = strain;
string result = JsonConvert.SerializeObject(strainDv);
pair[strainNormalKey] = result;
strainDv.ValueType = "005";
strainDv.Value = ptv.temperature;
string tempKey = ptv.SensorId + "-005";
result = JsonConvert.SerializeObject(strainDv);
pair[tempKey] = result;
Strain_Data sd = new Strain_Data();
sd.SensorId = ptv.SensorId;
sd.TimeStamp = ptv.Stamp;
sd.Frequency = ptv.frequency;
sd.Strain = strain;
sd.Temperature = ptv.temperature;
string mq_string = JsonConvert.SerializeObject(sd);
RabbitMsg msg = new RabbitMsg();
msg.RouteKey = ptv.SensorId;
msg.Body = mq_string;
dataQueue.Enqueue(msg);
ptv.isUpdated = false;
str += ptv.SensorId + "\r\n";
str += "R0: " + ptv.R0.ToString() + " T0: " + ptv.T0 + " G: " + ptv.G + " K: " + ptv.K + "\r\n";
str += "frequency: " + ptv.frequency + " temperature: " + ptv.temperature + "\r\n";
str += "Strain: " + strain.ToString() + "\r\n";
////lthis.AppendLog(str);
if (bgWorker.CancellationPending == true)
{
if (pair.Count > 0)
{
db_result.StringSet(pair.ToArray());
pair.Clear();
}
e.Cancel = true;
break;
}
}
else
{
//this.AppendLog(stamp + key + "is not updated");
continue;
}
}
if (pair.Count > 0)
{
db_result.StringSet(pair.ToArray());
pair.Clear();
}
//lthis.AppendLog(str);
//foreach (string key in list.Keys)
//{
// StaticStrainValue ptv = list[key];
// ptv.IsUpdated = false;
//}
}
catch (Exception ex)
{
this.AppendLog(ex.Message);
using (StreamWriter sw = new StreamWriter(@"ErrLog.txt", true))
{
sw.WriteLine(stamp + " " + ex.Message + " \r\n" + ex.StackTrace.ToString());
sw.WriteLine("---------------------------------------------------------");
sw.Close();
}
}
}
public string GetStringValue(string key)
{
return(_database.StringGet(key));
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log, ExecutionContext context)
{
FCnt serverFCnt;
string devEUI = req.Query["DevEUI"];
string fCntDown = req.Query["FCntDown"];
string fCntUp = req.Query["FCntUp"];
string gatewayId = req.Query["GatewayId"];
string ABPFcntCacheReset = req.Query["ABPFcntCacheReset"];
int newFCntDown = 0;
if (redisCache == null)
{
lock (typeof(FCntCacheChechk))
{
if (redisCache == null)
{
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
var redisConnectionString = config.GetConnectionString("RedisConnectionString");
if (string.IsNullOrEmpty(redisConnectionString))
{
string errorMsg = "Missing RedisConnectionString in settings";
throw new Exception(errorMsg);
}
var redis = ConnectionMultiplexer.Connect(redisConnectionString);
redisCache = redis.GetDatabase();
}
}
}
if (!string.IsNullOrEmpty(ABPFcntCacheReset))
{
redisCache.KeyDelete(devEUI);
return((ActionResult) new OkObjectResult(null));
}
if (!String.IsNullOrEmpty(devEUI) && !String.IsNullOrEmpty(fCntDown) && !String.IsNullOrEmpty(fCntUp) && !String.IsNullOrEmpty(gatewayId))
{
int clientFCntDown = int.Parse(fCntDown);
int clientFCntUp = int.Parse(fCntUp);
string cacheKey = devEUI;
try
{
if (redisCache.LockTake(cacheKey + "msglock", gatewayId, new TimeSpan(0, 0, 10)))
{
string cachedFCnt = redisCache.StringGet(cacheKey, CommandFlags.DemandMaster);
//we have it cached
if (!string.IsNullOrEmpty(cachedFCnt))
{
serverFCnt = (FCnt)JsonConvert.DeserializeObject(cachedFCnt, typeof(FCnt));
//it is a new message coming up by the first gateway
if (clientFCntUp > serverFCnt.FCntUp)
{
if (clientFCntDown >= serverFCnt.FCntDown)
{
newFCntDown = (int)(clientFCntDown + 1);
}
else
{
newFCntDown = (int)(serverFCnt.FCntDown + 1);
}
serverFCnt.FCntUp = clientFCntUp;
serverFCnt.FCntDown = newFCntDown;
serverFCnt.GatewayId = gatewayId;
CacheFcnt(serverFCnt, redisCache, cacheKey);
}
//it is a retry message coming up by the same first gateway
else if (clientFCntUp == serverFCnt.FCntUp && gatewayId == serverFCnt.GatewayId)
{
newFCntDown = serverFCnt.FCntDown + 1;
serverFCnt.FCntDown = newFCntDown;
CacheFcnt(serverFCnt, redisCache, cacheKey);
}
else
{
//we tell not to send any ack or downstream msg
newFCntDown = 0;
}
}
//it is the first message from this device
else
{
newFCntDown = clientFCntDown + 1;
serverFCnt = new FCnt();
serverFCnt.FCntDown = newFCntDown;
serverFCnt.FCntUp = clientFCntUp;
serverFCnt.GatewayId = gatewayId;
CacheFcnt(serverFCnt, redisCache, cacheKey);
}
}
}
finally
{
redisCache.LockRelease(cacheKey + "msglock", gatewayId);
}
}
else
{
string errorMsg = "Missing DevEUI or FCntDown or FCntUp or GatewayId";
throw new Exception(errorMsg);
}
return((ActionResult) new OkObjectResult(newFCntDown));
}
/// <summary>
/// Get a value that is associated with a key from the Redis cache
/// </summary>
/// <param name="key">the key to attempt to get</param>
/// <returns>null: if the key does not exist in the database, string if it does</returns>
public string get(string key)
{
// get and return
return(db.StringGet(key));
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log, ExecutionContext context)
{
//ABP Case
string devAddr = req.Query["DevAddr"];
//OTAA Case
string devEUI = req.Query["DevEUI"];
string devNonce = req.Query["DevNonce"];
string gatewayId = req.Query["GatewayId"];
if (redisCache == null || registryManager == null)
{
lock (typeof(FCntCacheChechk))
{
if (redisCache == null || registryManager == null)
{
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
string connectionString = config.GetConnectionString("IoTHubConnectionString");
if (connectionString == null)
{
string errorMsg = "Missing IoTHubConnectionString in settings";
throw new Exception(errorMsg);
}
string redisConnectionString = config.GetConnectionString("RedisConnectionString");
if (redisConnectionString == null)
{
string errorMsg = "Missing RedisConnectionString in settings";
throw new Exception(errorMsg);
}
registryManager = RegistryManager.CreateFromConnectionString(connectionString);
var redis = ConnectionMultiplexer.Connect(redisConnectionString);
redisCache = redis.GetDatabase();
}
}
}
List <IoTHubDeviceInfo> results = new List <IoTHubDeviceInfo>();
//OTAA join
if (devEUI != null)
{
string cacheKey = devEUI + devNonce;
try
{
if (redisCache.LockTake(cacheKey + "joinlock", gatewayId, new TimeSpan(0, 0, 10)))
{
//check if we already got the same devEUI and devNonce it can be a reaply attack or a multigateway setup recieving the same join.We are rfusing all other than the first one.
string cachedDevNonce = redisCache.StringGet(cacheKey, CommandFlags.DemandMaster);
if (!String.IsNullOrEmpty(cachedDevNonce))
{
return((ActionResult) new BadRequestObjectResult("UsedDevNonce"));
}
redisCache.StringSet(cacheKey, devNonce, new TimeSpan(0, 1, 0), When.Always, CommandFlags.DemandMaster);
IoTHubDeviceInfo iotHubDeviceInfo = new IoTHubDeviceInfo();
var device = await registryManager.GetDeviceAsync(devEUI);
if (device != null)
{
iotHubDeviceInfo.DevEUI = devEUI;
iotHubDeviceInfo.PrimaryKey = device.Authentication.SymmetricKey.PrimaryKey;
results.Add(iotHubDeviceInfo);
//clear device FCnt cache after join
redisCache.KeyDelete(devEUI);
}
}
}
finally
{
redisCache.LockRelease(cacheKey + "joinlock", gatewayId);
}
}
//ABP or normal message
else if (devAddr != null)
{
//TODO check for sql injection
devAddr = devAddr.Replace('\'', ' ');
var query = registryManager.CreateQuery($"SELECT * FROM devices WHERE properties.desired.DevAddr = '{devAddr}' OR properties.reported.DevAddr ='{devAddr}'", 100);
while (query.HasMoreResults)
{
var page = await query.GetNextAsTwinAsync();
foreach (var twin in page)
{
if (twin.DeviceId != null)
{
IoTHubDeviceInfo iotHubDeviceInfo = new IoTHubDeviceInfo();
iotHubDeviceInfo.DevAddr = devAddr;
var device = await registryManager.GetDeviceAsync(twin.DeviceId);
iotHubDeviceInfo.DevEUI = twin.DeviceId;
iotHubDeviceInfo.PrimaryKey = device.Authentication.SymmetricKey.PrimaryKey;
results.Add(iotHubDeviceInfo);
break;
}
}
}
}
else
{
string errorMsg = "Missing devEUI or devAddr";
throw new Exception(errorMsg);
}
string json = JsonConvert.SerializeObject(results);
return((ActionResult) new OkObjectResult(json));
}
public virtual T GetValue <T>(string key)
{
return(JsonConvert.DeserializeObject <T>(_db.StringGet(key)));
}
protected void Page_Load(object sender, EventArgs e)
{
UserClient user = new UserClient();
string result = user.ShowName("wcf");
Thread.Sleep(20);
Response.Write(result + "</br>");
//mysql数据库查询
MySqlConnection MySqlconn = new MySqlConnection(ConfigurationManager.ConnectionStrings["MySqlConStr"].ConnectionString.ToString());
try
{
MySqlconn.Open();
string MySqlcommand = "select T_Flowers.name as fname, T_Flowers.price as fprice, T_House.hname as hnames from T_Flowers left join T_House on T_Flowers.id = T_House.flowerid where T_House.hname = 'house1'";
MySqlCommand cmd = new MySqlCommand(MySqlcommand, MySqlconn);
Thread.Sleep(20);
MySqlDataReader myreader = cmd.ExecuteReader();
if (myreader.Read())
{
for (int i = 0; i <= 2; i++)
{
Response.Write(myreader[i].ToString() + " ");
}
myreader.Close();
}
}
catch (Exception ex)
{
Response.Write(ex.Message);
}
finally
{
if (MySqlconn != null)
{
MySqlconn.Close();
}
Response.Write("Mysql" + "</br>");
}
//连接数据库 StackExchange.Redis
string conn = ConfigurationManager.AppSettings["redis"].ToString();
Thread.Sleep(20);
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(conn);
//访问数据库 给db赋值
IDatabase db = redis.GetDatabase();
db.StringSet("rr", "StackExchange redisTest");
string value = db.StringGet("rr");
Response.Write(value + "</br>");
db.KeyDelete("rr");
//ServiceStack.Redis
//连接数据库
string conn2 = ConfigurationManager.AppSettings["redis2"].ToString();
RedisClient dbclient = new RedisClient(conn2);
Thread.Sleep(20);
dbclient.Set <string>("ee", "ServiceStack.Redis test");
string ee = dbclient.Get <string>("ee");
Response.Write(ee + "</br>");
dbclient.Set <int>("w22", 23);
dbclient.Get <int>("w22");
dbclient.Del("ee");
dbclient.Del("w22");
}
public string GetCache(string key)
{
return(_cache.StringGet(key).ToString());
}
private string StringGetInternal(string key, CommandFlags flags = default)
{
var result = _database.StringGet(GetKeyName(key), flags);
return(GetDecompressedString(result));
}
public static Action <RedisChannel, RedisValue> TransactionProcessHandler(ILogger logger,
IDatabase redis)
{
return((channel, message) => {
logger.Here().Information("BGN");
byte[] bytes = message;
TransactionProcessed transaction = TransactionProcessed.Parser.ParseFrom(bytes);
RedisValue transactionId = redis.StringGet(transaction.TransactionId);
if (transactionId.HasValue)
{
return;
}
redis.StringSet(transaction.TransactionId, "1", TimeSpan.FromMinutes(EXPIRATION_MINUTES));
logger.Here().Information("Updating Quote");
CacheData data = Cache.Get(redis, transaction.Ticker);
Quote quote = new Quote();
bool isNewer = (data == null || transaction.CreatedTimestamp > data.Timestamp);
quote.Bid = isNewer ? transaction.Level2.Bids[0].Price : data.Quote.Bid;
quote.Ask = isNewer ? transaction.Level2.Asks[0].Price : data.Quote.Ask;
quote.Last = isNewer ? transaction.Last : data.Quote.Last;
quote.Volume = (data == null ? 0 : data.Quote.Volume) +
transaction.Volume;
Cache.Set(redis, transaction.Ticker,
new CacheData(isNewer ? transaction.CreatedTimestamp : data.Timestamp,
quote, isNewer ? transaction.Level2 : data.Level2));
logger.Here().Information("Updating HistoricPrice 10 seconds");
String key = Constants.Redis.HISTORIC_PRICE + PriceType.TenSeconds +
"_" + transaction.Ticker;
RedisValue secondPrice = redis.StringGet(key);
if (secondPrice.HasValue)
{
byte[] secondPriceBytes = (RedisValue)secondPrice;
HistoricalPrice current = HistoricalPrice.Parser.ParseFrom(secondPriceBytes);
if ((current.Timestamp + (10 * TimeSpan.TicksPerSecond)) > transaction.CreatedTimestamp)
{
current.Close = transaction.Last;
if (transaction.Last > current.High)
{
current.High = transaction.Last;
}
if (transaction.Last < current.Low)
{
current.Low = transaction.Last;
}
current.Volume += transaction.Volume;
redis.StringSet(key, current.ToByteArray());
}
else
{
redis.StringSet(key, new HistoricalPrice()
{
Timestamp = ToTop10Second(transaction.CreatedTimestamp),
Open = transaction.Last,
Close = transaction.Last,
High = transaction.Last,
Low = transaction.Last,
Volume = transaction.Volume
}.ToByteArray());
}
}
else
{
redis.StringSet(key, new HistoricalPrice()
{
Timestamp = ToTop10Second(transaction.CreatedTimestamp),
Open = transaction.Last,
Close = transaction.Last,
High = transaction.Last,
Low = transaction.Last,
Volume = transaction.Volume
}.ToByteArray());
}
logger.Here().Information("END");
});
}
public Data ReadFromCache(string id)
{
Data d = Newtonsoft.Json.JsonConvert.DeserializeObject <Data>(cachingDB.StringGet(id.ToString()));
return(d);
}
public string Get(string key)
{
return(database.StringGet(key));
}
/// <summary>
/// Get
/// </summary>
/// <param name="key">key</param>
/// <param name="dbIndex">(optional) index, default <c>RedisDefaultDb</c></param>
/// <returns>value</returns>
public string Get(string key, int dbIndex = RedisDefaultDb)
{
IDatabase db = this._redisConnectMultiplexer.GetDatabase(dbIndex);
return(db.StringGet(key));
}
private void SyncGeneration(IDatabase db)
{
var generationKey = CacheNamespace.GetGenerationKey();
var serverGenerationValue = db.StringGet(generationKey);
var serverGeneration = Convert.ToInt64(serverGenerationValue);
var currentGeneration = CacheNamespace.GetGeneration();
// Generation was cleared by someone else (shouldn't happen).
if (serverGenerationValue.IsNullOrEmpty)
{
db.StringSetAsync(
key: generationKey,
value: currentGeneration,
// Only set if someone else doesn't jump in and set it first.
when: When.NotExists,
flags: CommandFlags.FireAndForget
);
log.InfoFormat("setting server generation ({0}) because it is empty", currentGeneration);
}
// Generation was lowered by someone else (shouldn't happen).
else if (serverGeneration < CacheNamespace.GetGeneration())
{
var transaction = db.CreateTransaction();
// Only set if someone else doesn't jump in and set it first.
transaction.AddCondition(Condition.StringEqual(generationKey, serverGeneration));
transaction.StringSetAsync(
key: generationKey,
value: CacheNamespace.GetGeneration(),
flags: CommandFlags.FireAndForget
);
// We don't need to worry about the result because we will
// already retry if we can't sync the generation.
transaction.ExecuteAsync(CommandFlags.FireAndForget);
log.InfoFormat("syncing server generation (server={0}, current={1})", serverGeneration, currentGeneration);
}
else
{
CacheNamespace.SetHigherGeneration(serverGeneration);
log.InfoFormat("syncing server generation (server={0}, current={1})", serverGeneration, currentGeneration);
}
}
private static void TestConcurrent(IDatabase db, RedisKey key, int SyncLoop, int Threads)
{
long value;
db.KeyDelete(key, CommandFlags.FireAndForget);
var time = RunConcurrent(delegate
{
for (int i = 0; i < SyncLoop; i++)
{
db.StringIncrement(key);
}
}, Threads, timeout: 45000);
value = (long)db.StringGet(key);
Assert.AreEqual(SyncLoop * Threads, value);
Console.WriteLine("Sync: {0} INCR using {1} threads, {2:###,##0}ms, {3} ops/s; final value: {4}",
SyncLoop * Threads, Threads,
(long)time.TotalMilliseconds,
(long)((SyncLoop * Threads) / time.TotalSeconds),
value);
}
public static RedisSessionStateStore Get(IDatabase database, string id)
{
var json = database.StringGet(id);
int timeout;
try
{
var jobject = JObject.Parse(json);
timeout = jobject.Value<int>("Timeout");
}
catch (Exception)
{
timeout = 20;
}
return new RedisSessionStateStore(database, id, TimeSpan.FromMinutes(timeout), GetHashKey(id));
}
public string GetString([FromQuery] string key)
{
return(_database.StringGet(key));
}
/// <summary>
/// Gets the game state from the database based on the gameID.
/// </summary>
/// <param name="gameID">The game's ID.</param>
/// <returns>The current state of the game.</returns>
public string GetGameState(string gameID)
{
return(db.StringGet(gameID));
}
private void LoopTask(IDatabase db)
{
int idx = 1;
while (true)
{
string loopMsg = string.Format("GET#{0} for key '{1}'...", idx, testKey);
WriteConnectionMsg(loopMsg);
bool callSuccess = false;
try
{
fileStreamWriter.WriteLine(DateTime.Now.ToString("HH:mm:ss.ffff") + " " + loopMsg + "...");
RedisValue redisValue = db.StringGet(testKey);
callSuccess = !redisValue.IsNullOrEmpty && redisValue == testValue;
}
catch (Exception e)
{
fileStreamWriter.WriteLine(DateTime.Now.ToString("HH:mm:ss.ffff") + " " + loopMsg + " failed on error: " + e.Message);
}
WriteConnectionMsg(loopMsg + " " + GetResultString(callSuccess));
if (stopEvent.WaitOne(1))
{
WriteConnectionMsg(string.Format("LoopTask was cancelled on {0} loop (before delay).", idx));
break;
}
Thread.Sleep(1000);
if (stopEvent.WaitOne(1))
{
WriteConnectionMsg(string.Format("LoopTask was cancelled on {0} loop (after delay).", idx));
break;
}
idx++;
}
}
private void ensureRedis(IDatabase db)
{
db.StringSet("testkey", "testvalue");
byte[] value = db.StringGet("testkey");
Console.WriteLine("got from redis: %s", value);
}
private void GradeButton_Click(object sender, EventArgs e)
{
_redis = ConnectionMultiplexer.Connect(_redisHost);
if (_redis == null)
return;
_db = _redis.GetDatabase();
if (_db == null)
return;
RedisValue capturedRv= _db.StringGet(Constants.REDIS_KEY_CAPTURED_DATA);
RedisValue origRv = _db.StringGet(Constants.REDIS_KEY_OIRG_DATA);
string[] capturedDataArr = capturedRv.ToString()
.Split(Constants.REDIS_SEPERATE_SYMBOL.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
string[] origDataArr = origRv.ToString()
.Split(Constants.REDIS_SEPERATE_SYMBOL.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
/*
using (FileStream fs = new FileStream("d:\\temp\\Orig.data", FileMode.OpenOrCreate))
{
byte[] data = new UTF8Encoding().GetBytes(origRv);
fs.Write(data, 0, data.Length);
fs.Flush();
fs.Close();
}
using (FileStream fs = new FileStream("d:\\temp\\Capt.data", FileMode.OpenOrCreate))
{
byte[] data = new UTF8Encoding().GetBytes(capturedRv);
fs.Write(data, 0, data.Length);
fs.Flush();
fs.Close();
}
*/
var settings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };
MotionData[] capturedData = new MotionData[capturedDataArr.Length];
int capturedCounter = 0;
foreach (var str in capturedDataArr)
{
capturedData[capturedCounter] = JsonConvert.DeserializeObject<MotionData>(str, settings);
capturedCounter++;
}
MotionData[] origData = new MotionData[origDataArr.Length];
int origCounter = 0;
foreach (var str in origDataArr)
{
origData[origCounter] = JsonConvert.DeserializeObject<MotionData>(str, settings);
origCounter++;
}
double score = Constants.MAX_SCORE - ProcessVideo.CalculateScore(capturedData, origData);
ScoreLabel.Text = "得分: " + score.ToString();
//Clear db
_db.StringSet(Constants.REDIS_KEY_CAPTURED_DATA, "");
_db.StringSet(Constants.REDIS_KEY_OIRG_DATA, "");
}
private static void _AppendToCacheValue(IDatabase database)
{
const string appendString = " appended";
database.StringAppend(StringCacheValue, appendString);
var retrievedValue = database.StringGet(StringCacheKey);
var expected = $"{StringCacheKey}{appendString}";
Console.WriteLine($"AppendToCacheValue: Expected = {expected}, Actual = {retrievedValue}");
}