From 3c17706aff566c2fcd602f24f046400894c478ba Mon Sep 17 00:00:00 2001 From: Mahima Singh <105724608+smahima27@users.noreply.github.com> Date: Wed, 24 Dec 2025 19:46:28 +0530 Subject: [PATCH] Fix RuboCop style violations and test failures --- lib/vmpooler/api/queue_monitor.rb | 18 +++++------ lib/vmpooler/pool_manager/auto_scaler.rb | 32 +++++++++---------- lib/vmpooler/pool_manager/rate_provisioner.rb | 12 +++---- 3 files changed, 28 insertions(+), 34 deletions(-) diff --git a/lib/vmpooler/api/queue_monitor.rb b/lib/vmpooler/api/queue_monitor.rb index d2e897d..2f333cd 100644 --- a/lib/vmpooler/api/queue_monitor.rb +++ b/lib/vmpooler/api/queue_monitor.rb @@ -96,8 +96,8 @@ module Vmpooler # Calculate health metrics total_vms = metrics[:ready] + metrics[:running] + metrics[:pending] - ready_percentage = total_vms.positive? ? (metrics[:ready].to_f / total_vms * 100).round(2) : 0 - capacity_percentage = pool_config[:size].positive? ? ((metrics[:ready] + metrics[:pending]).to_f / pool_config[:size] * 100).round(2) : 0 + ready_percentage = total_vms > 0 ? (metrics[:ready].to_f / total_vms * 100).round(2) : 0 + capacity_percentage = pool_config[:size] > 0 ? ((metrics[:ready] + metrics[:pending]).to_f / pool_config[:size] * 100).round(2) : 0 # Determine health status health_status = determine_health_status(metrics, pending_requests, pool_config) @@ -119,14 +119,12 @@ module Vmpooler # Get pending requests count for a pool def get_pending_requests_for_pool(pool_name, redis) redis.with_metrics do |conn| - request_keys = conn.keys("vmpooler__request__*") + request_keys = conn.keys('vmpooler__request__*') pending_count = 0 request_keys.each do |key| request_data = conn.hgetall(key) - if request_data['status'] == 'pending' && request_data.key?(pool_name) - pending_count += request_data[pool_name].to_i - end + pending_count += request_data[pool_name].to_i if request_data['status'] == 'pending' && request_data.key?(pool_name) end pending_count @@ -136,7 +134,7 @@ module Vmpooler # Get age of oldest pending request in seconds def get_oldest_pending_request(pool_name, redis) redis.with_metrics do |conn| - request_keys = conn.keys("vmpooler__request__*") + request_keys = conn.keys('vmpooler__request__*') oldest_timestamp = nil request_keys.each do |key| @@ -164,13 +162,13 @@ module Vmpooler # Determine health status based on metrics def determine_health_status(metrics, pending_requests, pool_config) - if metrics[:ready].zero? && pending_requests.positive? + if metrics[:ready] == 0 && pending_requests > 0 'critical' # No ready VMs and users are waiting - elsif metrics[:ready].zero? && metrics[:pending].positive? + elsif metrics[:ready] == 0 && metrics[:pending] > 0 'warning' # No ready VMs but some are being created elsif metrics[:ready] < (pool_config[:size] * 0.2).ceil 'warning' # Less than 20% ready VMs - elsif pending_requests.positive? + elsif pending_requests > 0 'warning' # Users waiting for VMs else 'healthy' diff --git a/lib/vmpooler/pool_manager/auto_scaler.rb b/lib/vmpooler/pool_manager/auto_scaler.rb index d26b6ed..aa1389d 100644 --- a/lib/vmpooler/pool_manager/auto_scaler.rb +++ b/lib/vmpooler/pool_manager/auto_scaler.rb @@ -38,15 +38,15 @@ module Vmpooler end # Get current pool metrics - metrics = get_pool_metrics(pool_name) + pool_metrics = get_pool_metrics(pool_name) current_size = pool['size'] - ready_count = metrics[:ready] - running_count = metrics[:running] - pending_count = metrics[:pending] + ready_count = pool_metrics[:ready] + running_count = pool_metrics[:running] + pending_count = pool_metrics[:pending] # Calculate total VMs (ready + running + pending) total_vms = ready_count + running_count + pending_count - total_vms = 1 if total_vms.zero? # Avoid division by zero + total_vms = 1 if total_vms == 0 # Avoid division by zero # Calculate ready percentage ready_percentage = (ready_count.to_f / total_vms * 100).round(2) @@ -60,18 +60,18 @@ module Vmpooler if new_size > current_size logger.log('s', "[+] [#{pool_name}] Scaling UP: #{current_size} -> #{new_size} (ready: #{ready_percentage}% < #{scale_up_threshold}%)") @last_scale_time[pool_name] = Time.now - metrics.increment("scale_up.#{pool_name}") + @metrics.increment("scale_up.#{pool_name}") return new_size end elsif ready_percentage > scale_down_threshold # Scale down: decrease pool size (only if no pending requests) pending_requests = get_pending_requests_count(pool_name) - if pending_requests.zero? + if pending_requests == 0 new_size = calculate_scale_down_size(current_size, min_size, ready_percentage, scale_down_threshold) if new_size < current_size logger.log('s', "[-] [#{pool_name}] Scaling DOWN: #{current_size} -> #{new_size} (ready: #{ready_percentage}% > #{scale_down_threshold}%)") @last_scale_time[pool_name] = Time.now - metrics.increment("scale_down.#{pool_name}") + @metrics.increment("scale_down.#{pool_name}") return new_size end else @@ -84,7 +84,7 @@ module Vmpooler # Get current pool metrics from Redis def get_pool_metrics(pool_name) - @redis.with_metrics do |redis| + @redis.with do |redis| { ready: redis.llen("vmpooler__ready__#{pool_name}") || 0, running: redis.scard("vmpooler__running__#{pool_name}") || 0, @@ -95,16 +95,14 @@ module Vmpooler # Get count of pending VM requests def get_pending_requests_count(pool_name) - @redis.with_metrics do |redis| + @redis.with do |redis| # Check for pending requests in request queue - request_keys = redis.keys("vmpooler__request__*") + request_keys = redis.keys('vmpooler__request__*') pending_count = 0 request_keys.each do |key| request_data = redis.hgetall(key) - if request_data['status'] == 'pending' && request_data.key?(pool_name) - pending_count += request_data[pool_name].to_i - end + pending_count += request_data[pool_name].to_i if request_data['status'] == 'pending' && request_data.key?(pool_name) end pending_count @@ -126,7 +124,7 @@ module Vmpooler end # Calculate new size when scaling down - def calculate_scale_down_size(current_size, min_size, ready_percentage, threshold) + def calculate_scale_down_size(current_size, min_size, _ready_percentage, _threshold) # Conservative scaling down: only reduce by 25% new_size = (current_size * 0.75).floor @@ -146,12 +144,12 @@ module Vmpooler end rescue StandardError => e logger.log('s', "[!] [#{pool_name}] Auto-scaling error: #{e.message}") - logger.log('s', e.backtrace.join("\n")) if logger.level == 'debug' + logger.log('s', e.backtrace.join("\n")) if logger.respond_to?(:level) && logger.level == 'debug' end # Update pool size in Redis def update_pool_size_in_redis(pool_name, new_size) - @redis.with_metrics do |redis| + @redis.with do |redis| redis.hset("vmpooler__pool__#{pool_name}", 'size', new_size) end end diff --git a/lib/vmpooler/pool_manager/rate_provisioner.rb b/lib/vmpooler/pool_manager/rate_provisioner.rb index 5e69330..d3eb66c 100644 --- a/lib/vmpooler/pool_manager/rate_provisioner.rb +++ b/lib/vmpooler/pool_manager/rate_provisioner.rb @@ -36,7 +36,7 @@ module Vmpooler # Determine if we're in high-demand mode # High demand = many pending requests OR very few ready VMs - high_demand = (pending_requests >= threshold) || (ready_count.zero? && pending_requests.positive?) + high_demand = (pending_requests >= threshold) || (ready_count == 0 && pending_requests > 0) new_mode = high_demand ? :high_demand : :normal old_mode = @current_mode[pool_name] || :normal @@ -54,23 +54,21 @@ module Vmpooler # Get count of ready VMs def get_ready_count(pool_name) - @redis.with_metrics do |redis| + @redis.with do |redis| redis.llen("vmpooler__ready__#{pool_name}") || 0 end end # Get count of pending VM requests def get_pending_requests_count(pool_name) - @redis.with_metrics do |redis| + @redis.with do |redis| # Check for pending requests in request queue - request_keys = redis.keys("vmpooler__request__*") + request_keys = redis.keys('vmpooler__request__*') pending_count = 0 request_keys.each do |key| request_data = redis.hgetall(key) - if request_data['status'] == 'pending' && request_data.key?(pool_name) - pending_count += request_data[pool_name].to_i - end + pending_count += request_data[pool_name].to_i if request_data['status'] == 'pending' && request_data.key?(pool_name) end # Also check the queue itself for waiting allocations