public override Task <BoolResult> ScaleAsync(OperationContext context, IReadOnlyList <RedisClusterSize> scalePath) { var extraMessage = $"Path=[{string.Join(" -> ", scalePath)}]"; return(context.PerformOperationAsync(Tracer, async() => { for (var i = 0; i < scalePath.Count; i++) { await RefreshAsync(context.Token).ThrowIfFailureAsync(); if (i > 0) { // Validate that the Redis cluster's state is the one we expected var previous = scalePath[i - 1]; if (!ClusterSize.Equals(previous)) { return new BoolResult(errorMessage: $"Expected instance `{Name}` to have size `{previous}` but found `{ClusterSize}`"); } } var target = scalePath[i]; await RequestScaleAsync(context, target).ThrowIfFailureAsync(); } return BoolResult.Success; }, extraStartMessage: extraMessage, extraEndMessage: _ => extraMessage)); }
private Task <BoolResult> RequestScaleAsync(OperationContext context, RedisClusterSize targetClusterSize) { string extraMessage = $"CurrentClusterSize=[{ClusterSize}] TargetClusterSize=[{targetClusterSize}]"; return(context.PerformOperationAsync(Tracer, async() => { if (ClusterSize.Equals(targetClusterSize)) { return new BoolResult(errorMessage: $"No-op scale request attempted (`{ClusterSize}` -> `{targetClusterSize}`) on instance `{Name}`"); } if (!RedisScalingUtilities.CanScale(ClusterSize, targetClusterSize)) { return new BoolResult(errorMessage: $"Scale request `{ClusterSize}` -> `{targetClusterSize}` on instance `{Name}` is disallowed by Azure Cache for Redis"); } if (!IsReadyToScale) { return new BoolResult(errorMessage: $"Redis instance `{Name}` is not ready to scale, current provisioning state is `{RedisCache.ProvisioningState}`"); } var instance = RedisCache.Update(); if (!ClusterSize.Tier.Equals(targetClusterSize.Tier)) { switch (targetClusterSize.Tier.Plan) { case RedisPlan.Basic: instance = instance.WithBasicSku(targetClusterSize.Tier.Capacity); break; case RedisPlan.Standard: instance = instance.WithStandardSku(targetClusterSize.Tier.Capacity); break; case RedisPlan.Premium: instance = instance.WithPremiumSku(targetClusterSize.Tier.Capacity); break; } } if (ClusterSize.Shards != targetClusterSize.Shards) { instance = instance.WithShardCount(targetClusterSize.Shards); } await instance.ApplyAsync(context.Token); return BoolResult.Success; }, extraStartMessage: extraMessage, extraEndMessage: _ => extraMessage, pendingOperationTracingInterval: TimeSpan.FromMinutes(1))); }
private async Task <BoolResult> RequestScaleAsync(RedisClusterSize targetClusterSize, CancellationToken cancellationToken = default) { if (ClusterSize.Equals(targetClusterSize)) { return(new BoolResult(errorMessage: $"No-op scale request attempted (`{ClusterSize}` -> `{targetClusterSize}`) on instance `{Name}`")); } if (!RedisScalingUtilities.CanScale(ClusterSize, targetClusterSize)) { return(new BoolResult(errorMessage: $"Scale request `{ClusterSize}` -> `{targetClusterSize}` on instance `{Name}` is disallowed by Azure Cache for Redis")); } if (!IsReadyToScale) { return(new BoolResult(errorMessage: $"Redis instance `{Name}` is not ready to scale, current provisioning state is `{RedisCache.ProvisioningState}`")); } return(await SubmitScaleRequestAsync(targetClusterSize, cancellationToken)); }
public override async Task <BoolResult> ScaleAsync(IReadOnlyList <RedisClusterSize> scalePath, CancellationToken cancellationToken = default) { for (var i = 0; i < scalePath.Count; i++) { await RefreshAsync(cancellationToken).ThrowIfFailureAsync(); if (i > 0) { // Validate that the Redis cluster's state is the one we expected var previous = scalePath[i - 1]; if (!ClusterSize.Equals(previous)) { return(new BoolResult(errorMessage: $"Expected instance `{Name}` to have size `{previous}` but found `{ClusterSize}`")); } } var target = scalePath[i]; await RequestScaleAsync(target, cancellationToken).ThrowIfFailureAsync(); } return(BoolResult.Success); }
/// <summary> /// Gets called whenever the Custom Room Properties are updated. /// In this callback we are interested in the settings the MasterClient can apply to the WorldGenerator. /// If all possible settings are updated (and available within the updated properties), these settings are also used /// to update the Ingame Control Panel as well as the WorldGenerator on all clients. /// Afterwards the WorldGenerator creates a new world with the new settings. /// </summary> public override void OnRoomPropertiesUpdate(Hashtable propertiesThatChanged) { if (propertiesThatChanged.ContainsKey(WorldGenerator.Instance.SeedPropertiesKey) && propertiesThatChanged.ContainsKey(WorldGenerator.Instance.WorldSizePropertiesKey) && propertiesThatChanged.ContainsKey(WorldGenerator.Instance.ClusterSizePropertiesKey) && propertiesThatChanged.ContainsKey(WorldGenerator.Instance.WorldTypePropertiesKey)) { // Updating Seed int seed = (int)propertiesThatChanged[WorldGenerator.Instance.SeedPropertiesKey]; seedInputField.text = seed.ToString(); // Updating World Size WorldSize worldSize = (WorldSize)propertiesThatChanged[WorldGenerator.Instance.WorldSizePropertiesKey]; switch (worldSize) { case WorldSize.Tiny: { worldSizeDropdown.value = 0; break; } case WorldSize.Small: { worldSizeDropdown.value = 1; break; } case WorldSize.Medium: { worldSizeDropdown.value = 2; break; } case WorldSize.Large: { worldSizeDropdown.value = 3; break; } } // Updating Cluster Size ClusterSize clusterSize = (ClusterSize)propertiesThatChanged[WorldGenerator.Instance.ClusterSizePropertiesKey]; switch (clusterSize) { case ClusterSize.Small: { clusterSizeDropdown.value = 0; break; } case ClusterSize.Medium: { clusterSizeDropdown.value = 1; break; } case ClusterSize.Large: { clusterSizeDropdown.value = 2; break; } } // Updating World Type WorldType worldType = (WorldType)propertiesThatChanged[WorldGenerator.Instance.WorldTypePropertiesKey]; switch (worldType) { case WorldType.Flat: { worldTypeDropdown.value = 0; break; } case WorldType.Standard: { worldTypeDropdown.value = 1; break; } case WorldType.Mountain: { worldTypeDropdown.value = 2; break; } } // Generating a new world WorldGenerator.Instance.CreateWorld(); } }