Example #1
0
        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);
        }
Example #2
0
        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);
            }
        }
Example #3
0
        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);
        }
Example #5
0
        /// <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);
        }
Example #6
0
 /// <summary>
 /// 获取单个对象
 /// </summary>
 /// <param name="Key"></param>
 /// <returns></returns>
 public string StringGet(string key)
 {
     key = AddSysCustomKey(key);
     return(Database.StringGet(key));
 }
Example #7
0
 public string Select(string key)
 {
     return(_db.StringGet(key));
 }
Example #8
0
        private static void _SetAndGetStringCacheValue(IDatabase database)
        {
            database.StringSet(StringCacheKey, StringCacheValue);

            var retrievedValue = database.StringGet(StringCacheKey);
            Console.WriteLine($"Expected value = {StringCacheValue}, Retrieved value = {retrievedValue}");
        }
Example #9
0
        public string Get([FromQuery] string key)
        {
            var value = _database.StringGet(key);

            return(value);
        }
Example #10
0
        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();
                }
            }
        }
Example #11
0
 public byte[] GetData(string filename)
 {
     return(RedisCache.StringGet(filename));
 }
Example #12
0
        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));
        }
Example #14
0
 /// <summary>
 /// 获取 一个简单的字符串键值
 /// </summary>
 /// <param name="key">键</param>
 /// <returns>值</returns>
 public RedisValue StringGet(string key)
 {
     return(_base.StringGet(key));
 }
Example #15
0
 /// <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(".", "")));
 }
Example #16
0
 /// <summary>
 /// 获取缓存
 /// </summary>
 public static string GetCache(this IDatabase readis, string key)
 {
     return(readis.StringGet(key));
 }
Example #17
0
 //取值
 private void button3_Click(object sender, EventArgs e)
 {
     this.textBox5.Text = _db.StringGet("test");
 }
Example #18
0
 /// <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));
 }
Example #19
0
        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();
                }
            }
        }
Example #20
0
 public string GetStringValue(string key)
 {
     return(_database.StringGet(key));
 }
Example #21
0
        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));
        }
Example #22
0
 /// <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));
 }
Example #23
0
        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));
        }
Example #24
0
 public virtual T GetValue <T>(string key)
 {
     return(JsonConvert.DeserializeObject <T>(_db.StringGet(key)));
 }
Example #25
0
        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");
        }
Example #26
0
 public string GetCache(string key)
 {
     return(_cache.StringGet(key).ToString());
 }
Example #27
0
        private string StringGetInternal(string key, CommandFlags flags = default)
        {
            var result = _database.StringGet(GetKeyName(key), flags);

            return(GetDecompressedString(result));
        }
Example #28
0
        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);
        }
Example #30
0
 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);
            }
        }
Example #33
0
 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));
            }
Example #35
0
 public string GetString([FromQuery] string key)
 {
     return(_database.StringGet(key));
 }
Example #36
0
 /// <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));
 }
Example #37
0
        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++;
            }
        }
Example #38
0
 private void ensureRedis(IDatabase db)
 {
     db.StringSet("testkey", "testvalue");
     byte[] value = db.StringGet("testkey");
     Console.WriteLine("got from redis: %s", value);
 }
Example #39
0
        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, "");
        }
Example #40
-1
 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}");
 }