private bool _IsRightType(RedisType type, params string[] keys)
{
//
if (type == RedisType.None)
{
return(false);
}
//
if (keys == null || keys.Length == 0)
{
return(false);
}
//
if (keys.Length == 1)
{
return(_DataType(keys[0]) == type);
}
if (keys.Length > 1)
{
var flag = true;
foreach (var item in keys)
{
var typeFlag = _DataType(item) == type;
if (!typeFlag)
{
flag = false;
break;
}
}
return(flag);
}
return(false);
}
public static RedisKey Get(RedisType redisType, TreeViewItem item, IEventAggregator eventAggregator)
{
RedisKey key;
switch (redisType)
{
case RedisType.String:
key = new RedisKeyString(item, eventAggregator);
break;
case RedisType.Set:
key = new RedisKeySet(item, eventAggregator);
break;
case RedisType.List:
key = new RedisKeyList(item, eventAggregator);
break;
case RedisType.Hash:
key = new RedisKeyHash(item, eventAggregator);
break;
case RedisType.SortedSet:
key = new RedisKeySortedSet(item, eventAggregator);
break;
default:
key = new RedisKeyString(item, eventAggregator);
break;
}
return(key);
}
internal protected bool Delete(RedisType type, params string[] keys)
{
//
if (keys == null ||
keys.Length == 0)
{
return(true);
}
//
if (!_IsRightType(type, keys))
{
return(false);
}
//
if (keys.Length == 1)
{
return(_DB.KeyDelete(keys[0]));
}
if (keys.Length > 1)
{
var keyx = keys.Select(it => (RedisKey)it).ToArray();
var num = _DB.KeyExists(keyx);
return(_DB.KeyDelete(keyx) == num);
}
//
return(false);
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="database">Redis Database</param>
/// <param name="setKey">Redis Key Name</param>
/// <param name="keyType"></param>
protected AbstracRedisKey(IDatabase database, string setKey, RedisType keyType) : this(database, setKey)
{
if (!AssertKeyType(keyType))
{
throw new Exception($"Redis Key {setKey} Type Not {keyType}");
}
}
protected override object GetItem(string cacheKey)
{
cacheKey = StandardizeCacheKey(cacheKey);
if (GetDatabase(ConnectionType.Exists).KeyExists(cacheKey))
{
RedisType type = GetDatabase(ConnectionType.Read).KeyType(cacheKey);
if (type == RedisType.Hash)
{
var entries = GetDatabase(ConnectionType.Read).HashGetAll(cacheKey);
return(entries.ToDictionary <HashEntry, object, object>(new Func <HashEntry, object>(x => x.Name), new Func <HashEntry, object>(x => Deserialize(x.Value))));
}
else if (type == RedisType.Set || type == RedisType.SortedSet)
{
throw new InvalidOperationException($"Set based values do not support GetItem. CacheKey: {cacheKey}");
}
else
{
var val = GetDatabase(ConnectionType.Read).StringGet(cacheKey);
if (val.HasValue)
{
return(Deserialize(val));
}
}
}
return(null);
}
private void ChangeDisplayType()
{
if (item != null)
{
var redisTypeViewModelMap = new Dictionary <RedisType, IValueItem>
{
{ RedisType.String, KeyStringViewModel },
{ RedisType.Set, KeySetViewModel },
{ RedisType.List, KeyListViewModel },
{ RedisType.Hash, KeyHashViewModel },
{ RedisType.SortedSet, KeySortedSetViewModel }
};
if (!Maps.RedisTypeKeyMap.ContainsKey(selectedType))
{
selectedType = RedisType.String;
}
var olditem = item;
item = (RedisKey)Activator.CreateInstance(Maps.RedisTypeKeyMap[selectedType], item.Parent, eventAggregator);
if (item != null)
{
item.KeyName = olditem.KeyName;
item.KeyType = selectedType;
item.TTL = olditem.TTL;
item.Display = olditem.KeyName;
ActivateItem(redisTypeViewModelMap[selectedType]);
if (resetValue)
{
switch (item.KeyType)
{
case RedisType.String:
ResetKeyValue(string.Empty);
break;
case RedisType.Set:
case RedisType.List:
ResetKeyValue(new BindableCollection <NumberedStringWrapper>());
break;
case RedisType.Hash:
ResetKeyValue(new BindableCollection <HashWrapper>());
break;
case RedisType.SortedSet:
ResetKeyValue(new BindableCollection <ScoreWrapper>());
break;
}
}
}
resetValue = true; // If this is true, try to reset the value when displaying new type.
}
}
/// <summary>
/// 检测 KeyType 是否为预期类型
/// </summary>
/// <param name="expectation"></param>
/// <returns></returns>
protected bool AssertKeyType(RedisType expectation)
{
if (IsExist())
{
return(Database.KeyType(SetKey) == expectation);
}
return(true);
}
internal RedisResultInspector(RESPObject response, Int32 lineNumber)
{
Contract.Assert(response != null, "Result instpector without response object.");
Contract.Assert(lineNumber > 0, "Result inspectors start counting numbers from 1.");
_response = response;
_lineNumber = lineNumber;
RedisType = GetRedisType();
}
public RedisKeyInfo(RedisKey key, RedisType type,
DateTime?expiry = null, DateTime?lastAccessed = null)
{
if ((object)key == null)
{
throw new ArgumentNullException(nameof(key));
}
Name = key.ToString();
Type = type;
Expiry = expiry;
LastAccessed = lastAccessed;
}
private DataType ParseDataType(RedisType redisType)
{
switch (redisType)
{
case RedisType.String:
case RedisType.Set:
case RedisType.List:
return(DataType.String);
}
return(DataType.Unknown);
}
private StackExchangeRedisDataTypesEnum ConvertRedisType(RedisType redisType)
{
switch (redisType)
{
case RedisType.String:
return(StackExchangeRedisDataTypesEnum.String);
case RedisType.Hash:
return(StackExchangeRedisDataTypesEnum.Hash);
default:
return(StackExchangeRedisDataTypesEnum.String);
}
}
private static void AddChildren(TreeViewItem item, Queue <string> urn, RedisType ktype, IEventAggregator eventAggregator)
{
var keystr = urn.Dequeue();
var key = item.Children.FirstOrDefault(x => x.Display == keystr);
if (key == null)
{
key = RedisKeyFactory.Get(ktype, item, eventAggregator);
key.Display = keystr;
item.Children.Add(key);
}
if (urn.Count > 0)
{
AddChildren(key, urn, ktype, eventAggregator);
}
}
public async Task RefreshKeysAsync()
{
Keys.Clear();
EndPoint[] endpoints = Mx.GetEndPoints();
foreach (EndPoint ep in endpoints)
{
IServer server = Mx.GetServer(ep);
IEnumerable <RedisKey> keys = server.Keys();
foreach (RedisKey key in keys)
{
RedisType keyType = await Db.KeyTypeAsync(key);
Keys.Add(new RedisKeyViewModel(key.ToString(), keyType));
}
}
}
public static KeyViewModel Create(RedisType keyType, string keyName, DbNodeViewModel parent)
{
switch (keyType)
{
case RedisType.Hash:
return(new HashKeyViewModel(keyName, parent));
case RedisType.String:
return(new StringKeyViewModel(keyName, parent));
case RedisType.Set:
return(new SetKeyViewModel(keyName, parent));
case RedisType.SortedSet:
return(new ZSetKeyViewModel(keyName, parent));
case RedisType.List:
return(new ListKeyViewModel(keyName, parent));
}
return(null);
}
private void DisplayItem(RedisKey displayitem)
{
if (displayitem != null)
{
DatabaseName = displayitem.DatabaseName;
KeyNameTextBox = displayitem.KeyName;
SelectedType = displayitem.KeyType;
var ttl = displayitem.TTL;
if (ttl.HasValue)
{
TTLDateTimePicker = DateTime.Now + ttl.Value;
}
else
{
TTLDateTimePicker = null;
}
}
}
public RedisProvider GetRedisProvider(RedisType redisType = RedisType.CACHE_MASTER)
{
if (!_connections.ContainsKey(redisType))
{
lock (lockObj)
{
if (!_connections.ContainsKey(redisType))
{
var provider = new RedisProvider(redisType);
_connections.TryAdd(redisType, provider);
return(provider);
}
}
}
RedisProvider result;
if (_connections.TryGetValue(redisType, out result))
{
return(result);
}
throw new System.Exception("Error : RedisProvider Is Null ");
}
public static char Prefix(this RedisType dataType)
{
switch (dataType)
{
case RedisType.String:
return(RedisTypePrefix.String);
case RedisType.Error:
return(RedisTypePrefix.Error);
case RedisType.Integer:
return(RedisTypePrefix.Integer);
case RedisType.BulkString:
return(RedisTypePrefix.BulkString);
case RedisType.Array:
return(RedisTypePrefix.Array);
default:
throw new ArgumentOutOfRangeException(nameof(dataType));
}
}
public ActionResult RedisServer_GetKeys()
{
//ViewBag.ServerName = ServerName;
var redisServerModel = new RedisServerModel {
Name = "Redis"
};
//ConnectionMultiplexer con = ConnectionMultiplexer.Connect(GetRedisConfigurationString(ServerName));
//IDatabase cache = con.GetDatabase();
//ConnectionMultiplexer con = GetRedisConnectionMultiplexer(ServerName);
IDatabase cache = CoreServices.RedisConnectionMultiplexers.RedisMultiplexer.GetDatabase();
var endpoints = CoreServices.RedisConnectionMultiplexers.RedisMultiplexer.GetEndPoints(true);
var server = CoreServices.RedisConnectionMultiplexers.RedisMultiplexer.GetServer(endpoints[0]);
foreach (RedisKey key in server.Keys(0))
{
RedisType redisKeyType = cache.KeyType(key);
if (redisKeyType.ToString().ToLower() == "string")
{
redisServerModel.StringKeys.Add(key);
}
else if (redisKeyType.ToString().ToLower() == "hash")
{
redisServerModel.HashKeys.Add(key);
}
}
//con.Close();
return(View(redisServerModel));
}
private RedisResult FetchKey(string key)
{
RedisType redisKeyTypeResult = db.KeyType(new RedisKey(key));
String fetch = null;
List <string> para = new List <string>();
switch (redisKeyTypeResult)
{
case RedisType.None:
fetch = null;
break;
case RedisType.String:
fetch = "GET";
para.Add(key);
break;
case RedisType.Set:
fetch = "SMEMBERS";
para.Add(key);
break;
case RedisType.Hash:
fetch = "HGETALL";
//MessageBox.Show("HGETALL");
para.Add(key);
break;
default:
throw new NotImplementedException();
}
RedisResult redisResult = db.Execute(fetch, para.ToArray());
return(redisResult);
}
public LengthCondition(RedisKey key, RedisType type, int compareToResult, long expectedLength)
{
if (key.IsNull)
{
throw new ArgumentException(nameof(key));
}
this.key = key;
this.compareToResult = compareToResult;
this.expectedLength = expectedLength;
this.type = type;
switch (type)
{
case RedisType.Hash:
cmd = RedisCommand.HLEN;
break;
case RedisType.Set:
cmd = RedisCommand.SCARD;
break;
case RedisType.List:
cmd = RedisCommand.LLEN;
break;
case RedisType.SortedSet:
cmd = RedisCommand.ZCARD;
break;
case RedisType.String:
cmd = RedisCommand.STRLEN;
break;
default:
throw new ArgumentException(nameof(type));
}
}
public ExistsCondition(RedisKey key, RedisType type, RedisValue expectedValue, bool expectedResult)
{
if (key.IsNull)
{
throw new ArgumentException("key");
}
this.key = key;
this.type = type;
this.expectedValue = expectedValue;
this.expectedResult = expectedResult;
if (expectedValue.IsNull)
{
cmd = RedisCommand.EXISTS;
}
else
{
switch (type)
{
case RedisType.Hash:
cmd = RedisCommand.HEXISTS;
break;
case RedisType.Set:
cmd = RedisCommand.SISMEMBER;
break;
case RedisType.SortedSet:
cmd = RedisCommand.ZSCORE;
break;
default:
throw new ArgumentException(nameof(type));
}
}
}
public RedisKeyViewModel(RedisKey key, RedisType type)
{
Key = key;
Name = key.ToString();
Type = type;
}
internal static RedisItemType ToType(this RedisType type)
{
return((RedisItemType)(int)type);
}
ScanDatabaseAsync(int dbNumber, string pattern = "*",
int maxCount = Int32.MaxValue,
bool includeLastAccessed = false,
bool includeExpiry = false)
{
SortedDictionary <string, RedisKeyInfo> result =
new SortedDictionary <string, RedisKeyInfo>();
if (maxCount < 1)
{
return(result);
}
IDatabase dbx = await GetDatabaseAsync(dbNumber);
int ndx = 0;
int exceptionCount = 0;
foreach (RedisKey key in _server.Keys(dbNumber, pattern, 10000))
{
try
{
RedisType type = await dbx.KeyTypeAsync(key);
DateTime?expiry = null;
if (includeExpiry)
{
TimeSpan?ttl = await dbx.KeyTimeToLiveAsync(key);
if (ttl.HasValue)
{
expiry = DateTime.UtcNow.AddSeconds(
ttl.Value.TotalSeconds);
}
}
DateTime?lastAccessed = null;
if (includeLastAccessed)
{
RedisResult idleString = await dbx.ExecuteAsync(
"object",
new[] { "idletime", key.ToString() });
int idleSeconds = (int)idleString;
if (idleSeconds > 0)
{
lastAccessed = DateTime.UtcNow.AddSeconds(
-idleSeconds);
}
}
result.Add(key.ToString(), new RedisKeyInfo(key, type,
expiry, lastAccessed));
if (++ndx == maxCount)
{
break;
}
}
catch (Exception ex)
{
if (++exceptionCount > 100)
{
throw ex;
}
Console.WriteLine($"{ex.GetType().Name} while " +
$"loading details for {key}: '{ex.Message}'.");
}
}
return(result);
}
/// <summary>
/// 根据key返回存储的Redis类型
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static Redistype KeyType(string key)
{
RedisType rtype = CacheDatabase.KeyType(key);
return((Redistype)Enum.ToObject(typeof(Redistype), rtype.GetHashCode()));
}
public void SetDefault()
{
SelectedType = RedisType.String;
TTLDateTimePicker = null;
DatabaseName = 1;
}
/// <summary>
/// Parse the command line arguments and perform some validation checks.
/// </summary>
/// <param name="args">command line arguments</param>
private static void ParseArgs(string[] args)
{
string order = null;
int i = 0;
while (i < args.Length)
{
if (args[i].StartsWith("-Action=", StringComparison.CurrentCultureIgnoreCase))
{
int prefixLen = "-Action=".Length;
action = args[i].Substring(prefixLen);
i++;
continue;
}
else if (args[i].StartsWith("-Container=", StringComparison.CurrentCultureIgnoreCase))
{
int prefixLen = "-Container=".Length;
containerName = args[i].Substring(prefixLen);
i++;
continue;
}
else if (args[i].StartsWith("-FK=", StringComparison.CurrentCultureIgnoreCase))
{
int prefixLen = "-FK=".Length;
feedKey = args[i].Substring(prefixLen);
i++;
continue;
}
else if (args[i].StartsWith("-Name=", StringComparison.CurrentCultureIgnoreCase))
{
int prefixLen = "-Name=".Length;
environmentName = args[i].Substring(prefixLen);
i++;
continue;
}
else if (args[i].StartsWith("-OK=", StringComparison.CurrentCultureIgnoreCase))
{
int prefixLen = "-OK=".Length;
objKey = args[i].Substring(prefixLen);
i++;
continue;
}
else if (args[i].StartsWith("-Order=", StringComparison.CurrentCultureIgnoreCase))
{
int prefixLen = "-Order=".Length;
order = args[i].Substring(prefixLen);
// if order is specified, make sure it is a valid choice
if (!(order.Equals("ascending", StringComparison.CurrentCultureIgnoreCase) ||
order.Equals("descending", StringComparison.CurrentCultureIgnoreCase)))
{
Console.WriteLine("Usage error: order must be ascending or descending");
Usage();
Environment.Exit(0);
}
i++;
continue;
}
else if (args[i].Equals("-Persistent", StringComparison.CurrentCultureIgnoreCase))
{
redisType = RedisType.Persistent;
i++;
continue;
}
else if (args[i].StartsWith("-PK=", StringComparison.CurrentCultureIgnoreCase))
{
int prefixLen = "-PK=".Length;
partitionKey = args[i].Substring(prefixLen);
i++;
continue;
}
else if (args[i].StartsWith("-Table=", StringComparison.CurrentCultureIgnoreCase))
{
int prefixLen = "-Table=".Length;
tableName = args[i].Substring(prefixLen);
i++;
continue;
}
else if (args[i].Equals("-Volatile"))
{
redisType = RedisType.Volatile;
i++;
continue;
}
else
{
// default case
Console.WriteLine($"Unrecognized parameter: {args[i]}");
i++;
}
}
if (string.IsNullOrWhiteSpace(environmentName))
{
Console.WriteLine("Usage error: must specify name of environment");
Usage();
Environment.Exit(0);
}
if (action != "delete" && action != "get" && action != "get-info" && action != "get-rank-feed")
{
Console.WriteLine("Usage error: invalid action.");
Console.WriteLine(" Supported actions are delete, get, get-info, get-rank-feed");
Usage();
Environment.Exit(0);
}
if (action == "get-rank-feed")
{
if (order == null)
{
Console.WriteLine("Usage error: must specify ordering for get-rank-feed");
Usage();
Environment.Exit(0);
}
if (order.Equals("ascending", StringComparison.CurrentCultureIgnoreCase))
{
rankFeedOrder = Order.Ascending;
}
else if (order.Equals("descending", StringComparison.CurrentCultureIgnoreCase))
{
rankFeedOrder = Order.Descending;
}
if (feedKey == null)
{
Console.WriteLine("Usage error: must specify feed key for get-rank-feed");
Usage();
Environment.Exit(0);
}
}
if (action == "get" || action == "delete")
{
if (objKey == null)
{
Console.WriteLine("Usage error: must specify object key for get or delete");
Usage();
Environment.Exit(0);
}
}
if (action != "get-info" && (containerName == null || tableName == null || partitionKey == null))
{
Console.WriteLine("Usage error: must specify container name, table name, partition key.");
Usage();
Environment.Exit(0);
}
// avoid accidental modification to a persistent Redis instance in a production environment
if (action == "delete" && redisType == RedisType.Persistent && ProdConfiguration.IsProduction(environmentName))
{
Console.WriteLine("Error! Your configuration modifies a production service. Aborting...");
Environment.Exit(-1);
}
}
public RedisProvider(RedisType redisType)
{
Conn = ConnectionMultiplexer.Connect(BaseCore.AppSetting.GetSection("RedisConfig").GetValue <string>(redisType.ToString()));
RedisType = redisType;
}
private static IDatabase GetDb(RedisType redisType)
{
var intType = (int)redisType;
return(Manager.GetDatabase(intType));
}
