public override void ExecuteCmdlet()
        {
            Utility.ValidateResourceGroupAndResourceName(ResourceGroupName, Name);
            ResourceGroupName = CacheClient.GetResourceGroupNameIfNotProvided(ResourceGroupName, Name);

            RedisKeyType keyTypeToRegenerated = RedisKeyType.Primary;

            if (KeyType.Equals("Secondary"))
            {
                keyTypeToRegenerated = RedisKeyType.Secondary;
            }

            ConfirmAction(
                Force.IsPresent,
                string.Format(Resources.RegeneratingRedisCacheKey, Name, keyTypeToRegenerated.ToString()),
                string.Format(Resources.RegenerateRedisCacheKey, Name, keyTypeToRegenerated.ToString()),
                Name,
                () =>
            {
                CacheClient.RegenerateAccessKeys(ResourceGroupName, Name, keyTypeToRegenerated);
                RedisAccessKeys keysResponse = CacheClient.GetAccessKeys(ResourceGroupName, Name);
                WriteObject(keysResponse);
            }
                );
        }
        ///GENMHASH:861E02F6BBA5773E9337D78B346B0D6B:1E017460FECC66E20EB360CE96692158
        public async Task <IRedisAccessKeys> RegenerateKeyAsync(RedisKeyType keyType, CancellationToken cancellationToken = default(CancellationToken))
        {
            var response = await Manager.Inner.Redis.RegenerateKeyAsync(ResourceGroupName, Name, keyType, cancellationToken);

            cachedAccessKeys = new RedisAccessKeysImpl(response);
            return(cachedAccessKeys);
        }
Пример #3
0
        /// <summary>
        /// 通过输入变量获取rediskey 下一步为文件记录获取目录等级和文件名
        /// </summary>
        /// <param name="redisKeyType">redis 类型</param>
        /// <param name="exchangename">交易所短名字</param>
        /// <param name="symbol">币对儿</param>
        /// <param name="timestamp">记录的起始时间点</param>
        /// <returns></returns>
        public static string GetRedisKey(RedisKeyType redisKeyType, TimePeriodType timePeriod, string exchangename, string symbol, DateTime timestamp)
        {
            DateTime t   = TimerHelper.GetStartTimeStampByPreiod(timePeriod, timestamp);
            string   str = redisKeyType + "@" + timePeriod + "@" + exchangename + "@" + symbol.ToLower() + "@" + t.ToString("yyyy.MM.dd HH:mm");

            return(str);
        }
        public override void ExecuteCmdlet()
        {
            RedisKeyType keyTypeToRegenerated = RedisKeyType.Primary;

            if (KeyType.Equals("Secondary"))
            {
                keyTypeToRegenerated = RedisKeyType.Secondary;
            }

            if (!Force.IsPresent)
            {
                ConfirmAction(
                    Force.IsPresent,
                    string.Format(Resources.RegeneratingRedisCacheKey, Name, keyTypeToRegenerated.ToString()),
                    string.Format(Resources.RegenerateRedisCacheKey, Name, keyTypeToRegenerated.ToString()),
                    Name,
                    () => CacheClient.RegenerateAccessKeys(ResourceGroupName, Name, keyTypeToRegenerated)
                    );
            }
            else
            {
                CacheClient.RegenerateAccessKeys(ResourceGroupName, Name, keyTypeToRegenerated);
            }

            RedisListKeysResult keysResponse = CacheClient.GetAccessKeys(ResourceGroupName, Name);

            WriteObject(new RedisAccessKeys()
            {
                PrimaryKey   = keysResponse.PrimaryKey,
                SecondaryKey = keysResponse.SecondaryKey
            });
        }
 public static EntityType ParseType(RedisKeyType type)
 {
     if (type == RedisKeyType.String)
     {
         return(EntityType.String);
     }
     else if (type == RedisKeyType.SortedSet)
     {
         return(EntityType.SortedSet);
     }
     else if (type == RedisKeyType.Set)
     {
         return(EntityType.Set);
     }
     else if (type == RedisKeyType.List)
     {
         return(EntityType.List);
     }
     else if (type == RedisKeyType.Hash)
     {
         return(EntityType.Hash);
     }
     else
     {
         throw new Exception();
     }
 }
Пример #6
0
        internal static string ToSerializedValue(this RedisKeyType value)
        {
            switch (value)
            {
            case RedisKeyType.Primary:
                return("Primary");

            case RedisKeyType.Secondary:
                return("Secondary");
            }
            return(null);
        }
 public static EntityType ParseType(RedisKeyType type)
 {
     if (type == RedisKeyType.String)
         return EntityType.String;
     else if (type == RedisKeyType.SortedSet)
         return EntityType.SortedSet;
     else if (type == RedisKeyType.Set)
         return EntityType.Set;
     else if (type == RedisKeyType.List)
         return EntityType.List;
     else if (type == RedisKeyType.Hash)
         return EntityType.Hash;
     else
         throw new Exception();
 }
Пример #8
0
 /// <summary>
 /// Initializes a new instance of the RedisRegenerateKeyParameters
 /// class.
 /// </summary>
 /// <param name="keyType">The Redis access key to regenerate. Possible
 /// values include: 'Primary', 'Secondary'</param>
 public RedisRegenerateKeyParameters(RedisKeyType keyType)
 {
     KeyType = keyType;
     CustomInit();
 }
Пример #9
0
 /// <summary>
 /// Regenerate Redis cache's access keys. This operation requires write
 /// permission to the cache resource.
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='resourceGroupName'>
 /// The name of the resource group.
 /// </param>
 /// <param name='name'>
 /// The name of the Redis cache.
 /// </param>
 /// <param name='keyType'>
 /// The Redis access key to regenerate. Possible values include: 'Primary',
 /// 'Secondary'
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <RedisAccessKeysInner> RegenerateKeyAsync(this IRedisOperations operations, string resourceGroupName, string name, RedisKeyType keyType, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, name, keyType, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
 /// <summary>
 /// Regenerates the access keys for this Redis Cache.
 /// </summary>
 /// <param name="keyType">Key type to regenerate.</param>
 /// <return>The generated access keys for this Redis Cache.</return>
 Microsoft.Azure.Management.Redis.Fluent.IRedisAccessKeys Microsoft.Azure.Management.Redis.Fluent.IRedisCache.RegenerateKey(RedisKeyType keyType)
 {
     return(this.RegenerateKey(keyType) as Microsoft.Azure.Management.Redis.Fluent.IRedisAccessKeys);
 }
 internal IRedisAccessKeys RegenerateKey(RedisKeyType keyType)
 {
     return(Extensions.Synchronize(() => RegenerateKeyAsync(keyType)));
 }
 public RedisAccessKeys RegenerateAccessKeys(string resourceGroupName, string cacheName, RedisKeyType keyType)
 {
     return(_client.Redis.RegenerateKey(resourceGroupName: resourceGroupName, name: cacheName, parameters: new RedisRegenerateKeyParameters()
     {
         KeyType = keyType
     }));
 }
 /// <summary>
 /// Initializes a new instance of the RedisRegenerateKeyParameters
 /// class with required arguments.
 /// </summary>
 public RedisRegenerateKeyParameters(RedisKeyType keyType)
     : this()
 {
     this.KeyType = keyType;
 }
 public OperationResponse RegenerateAccessKeys(string resourceGroupName, string cacheName, RedisKeyType keyType)
 {
     return _client.Redis.RegenerateKey(resourceGroupName: resourceGroupName, name: cacheName, parameters: new RedisRegenerateKeyParameters() { KeyType = keyType });
 }
Пример #15
0
 /// <summary>
 /// Initializes a new instance of the RedisRegenerateKeyParameters
 /// class.
 /// </summary>
 public RedisRegenerateKeyParameters(RedisKeyType keyType)
 {
     KeyType = keyType;
 }
Пример #16
0
        private void treeKeys_AfterSelect(object sender, TreeViewEventArgs e)
        {
            string key         = GetFullKey(e.Node);
            bool   containsKey = RedisClient.ContainsKey(key);

            if (containsKey)
            {
                this.table.Clear();
                this.txtHashKey.Text = this.txtHashValue.Text = string.Empty;

                RedisKeyType keyType = RedisClient.GetEntryType(key);
                this.lblKey.Text = keyType.ToString();
                this.txtKey.Text = key;
                int row = 0;
                switch (keyType)
                {
                case RedisKeyType.Hash:
                    this.gridHash.Visible   = true;
                    this.column_key.Visible = this.column_value.Visible = true;
                    var hash = RedisClient.GetAllEntriesFromHash(key);
                    foreach (var item in hash)
                    {
                        table.Rows.Add(row + 1, item.Key, item.Value);
                        row++;
                    }
                    break;

                case RedisKeyType.List:
                    this.gridHash.Visible     = true;
                    this.column_key.Visible   = false;
                    this.column_value.Visible = true;
                    var list = RedisClient.GetAllItemsFromList(key);
                    for (; row < list.Count; row++)
                    {
                        table.Rows.Add(row + 1, "", list[row]);
                    }
                    break;

                case RedisKeyType.None:
                    break;

                case RedisKeyType.Set:
                    this.gridHash.Visible     = true;
                    this.column_key.Visible   = true;
                    this.column_value.Visible = false;
                    var set = RedisClient.GetAllItemsFromSet(key);
                    foreach (var item in set)
                    {
                        table.Rows.Add(row + 1, item, "");
                        row++;
                    }
                    break;

                case RedisKeyType.SortedSet:
                    this.gridHash.Visible = true;
                    var sortedSet = RedisClient.GetAllWithScoresFromSortedSet(key);
                    foreach (var item in sortedSet)
                    {
                        table.Rows.Add(row + 1, item.Key, item.Value);
                        row++;
                    }
                    break;

                case RedisKeyType.String:
                    this.txtHashValue.Text = RedisClient.GetValue(key);
                    break;

                default:
                    break;
                }
            }
        }
 /// <summary>
 /// Initializes a new instance of the RedisRegenerateKeyParameters
 /// class with required arguments.
 /// </summary>
 public RedisRegenerateKeyParameters(RedisKeyType keyType)
     : this()
 {
     this.KeyType = keyType;
 }