public RedisCacheService()
{
conf = new RedisEndpoint {
Host = "localhost", Port = 6379, Password = "", RetryTimeout = 1000
};
//conf = new RedisEndpoint { Host = _devnotConfig.Value.RedisEndPoint, Port = _devnotConfig.Value.RedisPort, Password = "" };
}
public void Does_set_all_properties_on_Client_using_ClientsManagers()
{
var connStr =
"redis://*****:*****@host:1?ssl=true&db=0&connectTimeout=2&sendtimeout=3&receiveTimeout=4&idletimeoutsecs=5&NamespacePrefix=prefix.";
var expected = new RedisEndpoint {
Host = "host",
Port = 1,
Ssl = true,
Client = "nunit",
Password = "******",
Db = 0,
ConnectTimeout = 2,
SendTimeout = 3,
ReceiveTimeout = 4,
IdleTimeoutSecs = 5,
NamespacePrefix = "prefix."
};
using (var pooledManager = new RedisManagerPool(connStr)) {
AssertClientManager(pooledManager, expected);
}
using (var pooledManager = new PooledRedisClientManager(connStr)) {
AssertClientManager(pooledManager, expected);
}
using (var basicManager = new BasicRedisClientManager(connStr)) {
AssertClientManager(basicManager, expected);
}
}
public RedisCacheHelper()
{
var host = ConfigurationManager.AppSettings["redisCacheHost"];
var port = Convert.ToInt32(ConfigurationManager.AppSettings["redisCachePort"]);
_redisEndpoint = new RedisEndpoint(host, port);
}
public RedisCacheRepository(IConfiguration configuration)
{
_configuration = configuration;
_redisConfiguration = new RedisEndpoint()
{
Host = _configuration["RedisConfig:Host"], Password = _configuration["RedisConfig:Password"], Port = Convert.ToInt32(_configuration["RedisConfig:Port"]), Ssl = Convert.ToBoolean(_configuration["RedisConfig:Ssl"])
};
}
public Form1()
{
InitializeComponent();
host = ConfigurationManager.AppSettings.Get("host");
port = Convert.ToInt32(ConfigurationManager.AppSettings.Get("port"));
redisEndpoint = new RedisEndpoint(host, port);
}
public void Can_use_password_with_equals()
{
var connString = "127.0.0.1?password="******"p@55w0rd=");
var config = RedisEndpoint.Create(connString);
Assert.That(config.Password, Is.EqualTo("p@55w0rd="));
}
public RedisCacheService(IConfiguration configuration)
{
_configuration = configuration;
_redisConfiguration = new RedisEndpoint()
{
Host = _configuration["RedisConfig:Host"], Password = _configuration["RedisConfig:Password"], Port = _configuration["RedisConfig:Port"].ToInt()
};
}
public RedisCacheService(IOptions <DevnotConfig> devnotConfig)
{
_devnotConfig = devnotConfig;
conf = new RedisEndpoint {
Host = _devnotConfig.Value.RedisEndPoint, Port = _devnotConfig.Value.RedisPort, Password = "", RetryTimeout = 1000
};
//conf = new RedisEndpoint { Host = _devnotConfig.Value.RedisEndPoint, Port = _devnotConfig.Value.RedisPort, Password = "" };
}
public RedisEndpoint ToRedisEndpoint()
{
RedisEndpoint endpoint = new RedisEndpoint();
endpoint.Host = Host;
endpoint.Port = Port;
endpoint.Db = DbNumber;
return(endpoint);
}
/// <summary>
/// Gets the redis client.
/// </summary>
/// <returns>Returns Interface of Redis Client</returns>
private IRedisClient GetRedisClient()
{
var redisEndpoint = new RedisEndpoint(this.host, this.port);
var redisClient = this.redisClientFactory.CreateRedisClient(redisEndpoint);
redisClient.Db = this.db;
return(redisClient);
}
public RedisCacheService()
{
_config = new RedisConfig
{
Host = Shell.GetConfigAs <string>("RedisConfig:Host"),
Port = Shell.GetConfigAs <int>("RedisConfig:Port"),
DatabaseId = GetDatabaseId()
};
_endPoint = new RedisEndpoint(_config.Host, _config.Port, null, _config.DatabaseId);
}
public RedisService(IOptions <RedisConfigModel> redisConfig)
{
_redisConfig = redisConfig;
if (_redisConfig != null)
{
conf = new RedisEndpoint {
Host = _redisConfig.Value.RedisEndPoint, Port = _redisConfig.Value.RedisPort, Password = "", RetryTimeout = 1000
}
}
;
}
public RedisCacheProvider(string connect)
{
if (!string.IsNullOrEmpty(connect))
{
var hostAndPort = connect.Split(':');
host = hostAndPort[0];
port = hostAndPort[1];
}
_endPoint = new RedisEndpoint(host, Convert.ToInt32(port));
}
private static void AssertClientManager(IRedisClientsManager redisManager, RedisEndpoint expected)
{
using var readWrite = (RedisClient)redisManager.GetClient();
using var readOnly = (RedisClient)redisManager.GetReadOnlyClient();
using var cacheClientWrapper = (RedisClientManagerCacheClient)redisManager.GetCacheClient();
AssertClient(readWrite, expected);
AssertClient(readOnly, expected);
using var cacheClient = (RedisClient)cacheClientWrapper.GetClient();
AssertClient(cacheClient, expected);
}
public void UpdateItem(Item item)
{
var conf = new RedisEndpoint()
{
Host = "xxxxxxxxxxxxxx.redis.cache.windows.net", Password = "******", Ssl = true, Port = 6380
};
using (IRedisClient client = new RedisClient(conf))
{
IRedisTypedClient <Item> itemClient = client.As <Item>();
IRedisList <Item> itemList = itemClient.Lists["urn:item:" + item.ProductID];
var index = itemList.Select((Value, Index) => new { Value, Index })
.Single(p => p.Value.Id == item.Id).Index;
var toUpdateItem = itemList.First(x => x.Id == item.Id);
//var index = itemList.IndexOf(toUpdateItem);
toUpdateItem.Name = item.Name;
toUpdateItem.Price = item.Price;
itemList.RemoveAt(index);
if (itemList.Count - 1 < index)
{
itemList.Add(toUpdateItem);
}
else
{
itemList.Insert(index, toUpdateItem);
}
client.RemoveItemFromSortedSet("urn:Rank", item.Name);
client.AddItemToSortedSet("urn:Rank", item.Name, item.Price);
//Publis top 5 Ranked Items
IDictionary <string, double> Data = client.GetRangeWithScoresFromSortedSet("urn:Rank", 0, 4);
List <Item> RankList = new List <Item>();
int counter = 0;
foreach (var itm in Data)
{
counter++;
RankList.Add(new Item()
{
Name = itm.Key, Price = (int)itm.Value, Id = counter
});
}
var itemJson = JsonConvert.SerializeObject(RankList);
client.PublishMessage("Rank", itemJson);
//---------------------------------------------
}
}
public void Can_Parse_Host()
{
var hosts = new[] { "[email protected]:6123" };
var endPoints = RedisEndpoint.Create(hosts);
Assert.AreEqual(1, endPoints.Count);
var ep = endPoints[0];
Assert.AreEqual("host.com", ep.Host);
Assert.AreEqual(6123, ep.Port);
Assert.AreEqual("pass", ep.Password);
}
public void Host_May_Contain_AtChar()
{
var hosts = new[] { "@pa1@ss@localhost:6123" };
var endPoints = RedisEndpoint.Create(hosts);
Assert.AreEqual(1, endPoints.Count);
var ep = endPoints[0];
Assert.AreEqual("@pa1@ss", ep.Password);
Assert.AreEqual("localhost", ep.Host);
Assert.AreEqual(6123, ep.Port);
}
public ActionResult Counter()
{
var host = ConfigurationManager.AppSettings["host"].ToString();
var port = Convert.ToInt32(ConfigurationManager.AppSettings["port"]);
RedisEndpoint redisEndpoint = new RedisEndpoint(host, port);
using (var client = new RedisClient(redisEndpoint))
{
ViewBag.Visit = client.Increment("Website_Counter", 1);
}
return(View());
}
public RedisCacheManager()
{
var configuration = (IConfiguration)ServiceTool.ServiceProvider.GetService(typeof(IConfiguration));
var redisConnectionInfo = configuration.GetValue <string>("RedisHostInformation").Split(':');
if (redisConnectionInfo.Length != 2 || int.TryParse(redisConnectionInfo[1], out var port) == false || port == 0)
{
throw new NullReferenceException();
}
_redisEndpoint = new RedisEndpoint(redisConnectionInfo[0], port);
}
public JsonResult GetProducts()
{
var conf = new RedisEndpoint()
{
Host = "xxxxxxxxxxxxxx.redis.cache.windows.net", Password = "******", Ssl = true, Port = 6380
};
using (IRedisClient client = new RedisClient(conf))
{
var productClient = client.As <Product>();
var products = productClient.GetAll();
return(Json(products, JsonRequestBehavior.AllowGet));
}
}
static void Main(string[] args)
{
var conf = new RedisEndpoint()
{
Host = "127.0.0.1", Port = 6379
};
Console.WriteLine("Services Start...");
using (IRedisClient client = new RedisClient(conf))
{
IRedisSubscription sub = null;
using (sub = client.CreateSubscription())
{
sub.OnMessage += (channel, news) =>
{
try
{
News _news = JsonConvert.DeserializeObject <News>(news);
Console.WriteLine(_news.Title);
//Güncellenecek 1. Redis Server'ı
var conf2 = new RedisEndpoint()
{
Host = "10.211.55.9", Port = 6379
};
using (IRedisClient clientServer = new RedisClient(conf2))
{
clientServer.Set <News>("RedisNews", _news);
}
//Güncellenecek 2. Redis Server'ı
var conf3 = new RedisEndpoint()
{
Host = "192.168.1.234", Port = 6379
};
using (IRedisClient clientServer2 = new RedisClient(conf3))
{
clientServer2.Set <News>("RedisNews", _news);
}
}
catch (Exception ex)
{
Console.WriteLine("Hata :" + ex.Message);
}
};
sub.SubscribeToChannels(new string[] { "News" });
}
}
Console.ReadLine();
}
private static void AssertClient(RedisClient redis, RedisEndpoint expected)
{
Assert.That(redis.Host, Is.EqualTo(expected.Host));
Assert.That(redis.Port, Is.EqualTo(expected.Port));
Assert.That(redis.Ssl, Is.EqualTo(expected.Ssl));
Assert.That(redis.Client, Is.EqualTo(expected.Client));
Assert.That(redis.Password, Is.EqualTo(expected.Password));
Assert.That(redis.Db, Is.EqualTo(expected.Db));
Assert.That(redis.ConnectTimeout, Is.EqualTo(expected.ConnectTimeout));
Assert.That(redis.SendTimeout, Is.EqualTo(expected.SendTimeout));
Assert.That(redis.ReceiveTimeout, Is.EqualTo(expected.ReceiveTimeout));
Assert.That(redis.IdleTimeOutSecs, Is.EqualTo(expected.IdleTimeOutSecs));
Assert.That(redis.NamespacePrefix, Is.EqualTo(expected.NamespacePrefix));
}
public RedisEndpoint GetMaster()
{
var sentinelWorker = this.GetValidSentinelWorker();
var host = sentinelWorker.GetMasterHost(this.MasterName);
if (this.ScanForOtherSentinels && DateTime.UtcNow - this._lastSentinelsRefresh > this.RefreshSentinelHostsAfter)
{
this.RefreshActiveSentinels();
}
return(host != null
? RedisEndpoint.Create(this.HostFilter != null?this.HostFilter(host) : host)
: null);
}
public void SaveProduct(Product product)
{
var conf = new RedisEndpoint()
{
Host = "xxxxxxxxxxxxxx.redis.cache.windows.net", Password = "******", Ssl = true, Port = 6380
};
using (IRedisClient client = new RedisClient(conf))
{
var userClient = client.As <Product>();
product.Id = userClient.GetNextSequence();
userClient.Store(product);
}
}
public JsonResult GetItems(int?productID)
{
var conf = new RedisEndpoint()
{
Host = "xxxxxxxxxxxxxx.redis.cache.windows.net", Password = "******", Ssl = true, Port = 6380
};
using (IRedisClient client = new RedisClient(conf))
{
var itemClient = client.As <Item>();
var itemList = itemClient.Lists["urn:item:" + productID];
var items = itemList.GetAll();
return(Json(items, JsonRequestBehavior.AllowGet));
}
}
public IActionResult Dummy()
{
var host = "redis-server";
var port = Convert.ToInt32("6379");
RedisEndpoint redisEndpoint = new RedisEndpoint(host, port);
using (var client = new RedisClient(redisEndpoint))
{
ViewBag.Visit = client.Increment("Website_Counter", 1);
// session["pagehit"] = ViewBag.Visit;
// ViewBag.tempvar = client.IncrBy("testvar", 5);
}
return(View());
}
private static void AssertClientManager(IRedisClientsManager redisManager, RedisEndpoint expected)
{
using (var readWrite = (RedisClient) redisManager.GetClient())
using (var readOnly = (RedisClient) redisManager.GetReadOnlyClient())
using (var cacheClientWrapper = (RedisClientManagerCacheClient) redisManager.GetCacheClient())
{
AssertClient(readWrite, expected);
AssertClient(readOnly, expected);
using (var cacheClient = (RedisClient) cacheClientWrapper.GetClient())
{
AssertClient(cacheClient, expected);
}
}
}
public JsonResult GetEditItem(int ProductID, int Id)
{
var conf = new RedisEndpoint()
{
Host = "xxxxxxxxxxxxxx.redis.cache.windows.net", Password = "******", Ssl = true, Port = 6380
};
using (IRedisClient client = new RedisClient(conf))
{
var itemClient = client.As <Item>();
var itemList = itemClient.Lists["urn:item:" + ProductID];
var toUpdateItem = itemList.First(x => x.Id == Id);
return(Json(toUpdateItem, JsonRequestBehavior.AllowGet));
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
await Task.Delay(1000, stoppingToken);
var conf = new RedisEndpoint()
{
Host = "****.redis.cache.windows.net", Port = 6379, Password = "******"
};
Console.WriteLine("Services Start...");
using (IRedisClient client = new RedisClient(conf))
{
IRedisSubscription sub = null;
using (sub = client.CreateSubscription())
{
sub.OnMessage += (channel, exchange) =>
{
try
{
ExchangeModel _exchange = JsonConvert.DeserializeObject <ExchangeModel>(exchange);
Console.WriteLine(_exchange.Name + ": " + _exchange.Value);
//Redis UPDATE
using (IRedisClient clientServer = new RedisClient(conf))
{
string redisKey = "Exchange:" + _exchange.ID;
clientServer.Set <ExchangeModel>(redisKey, _exchange);
}
//Sql UPDATE
using (BlackJackContext context = new BlackJackContext())
{
var exchangeModel = context.Exchange.FirstOrDefault(ex => ex.Id == _exchange.ID);
exchangeModel.Value = (decimal)_exchange.Value;
exchangeModel.UpdateDate = DateTime.Now;
context.SaveChanges();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
};
sub.SubscribeToChannels(new string[] { "Exchange" });
}
}
}
public void RedisManagerPool_can_execute_CustomResolver()
{
var resolver = new FixedResolver(RedisEndpoint.Create(Config.Sentinel6380), RedisEndpoint.Create(Config.Sentinel6381));
using (var redisManager = new RedisManagerPool("127.0.0.1:8888")
{
RedisResolver = resolver
}) {
using (var master = redisManager.GetClient()) {
Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380));
master.SetValue("KEY", "1");
}
using (var master = redisManager.GetClient()) {
Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380));
master.Increment("KEY", 1);
}
Assert.That(resolver.NewClientsInitialized, Is.EqualTo(1));
for (var i = 0; i < 5; i++)
{
using (var slave = redisManager.GetReadOnlyClient()) {
Assert.That(slave.GetHostString(), Is.EqualTo(Config.Sentinel6380));
Assert.That(slave.GetValue("KEY"), Is.EqualTo("2"));
}
}
Assert.That(resolver.NewClientsInitialized, Is.EqualTo(1));
redisManager.FailoverTo("127.0.0.1:9999", "127.0.0.1:9999");
for (var i = 0; i < 5; i++)
{
using (var master = redisManager.GetClient()) {
Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380));
Assert.That(master.GetValue("KEY"), Is.EqualTo("2"));
}
using (var slave = redisManager.GetReadOnlyClient()) {
Assert.That(slave.GetHostString(), Is.EqualTo(Config.Sentinel6380));
Assert.That(slave.GetValue("KEY"), Is.EqualTo("2"));
}
}
Assert.That(resolver.NewClientsInitialized, Is.EqualTo(2));
}
}
protected bool hasDataOnRedis()
{
#region conf
var conf = new RedisEndpoint()
{
Host = "*************************.redis.cache.windows.net", Password = "******", Ssl = true, Port = 6380
};
#endregion
using (IRedisClient client = new RedisClient(conf))
{
if (client.SearchKeys("flag*").Count == 0)
{
return(false);
}
return(true);
}
}
public FixedResolver(RedisEndpoint master, RedisEndpoint slave)
{
this.master = master;
this.slave = slave;
}
public RedisClient CreateRedisClient(RedisEndpoint config, bool readWrite)
{
NewClientsInitialized++;
return RedisConfig.ClientFactory(config);
}
public SerializingRedisClient(RedisEndpoint config)
: base(config) {}
public FixedResolver(RedisEndpoint master, RedisEndpoint slave)
{
this.master = master;
this.slave = slave;
this.ClientFactory = RedisConfig.ClientFactory;
}
public RedisClient CreateRedisClient(RedisEndpoint config, bool master)
{
NewClientsInitialized++;
return ClientFactory(config);
}
