puppetlabs/vmpooler
2
0
Fork 0
mirror of https://github.com/puppetlabs/vmpooler.git synced 2026-01-25 17:48:41 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix RuboCop style violations and test failures

Browse source
This commit is contained in:
Mahima Singh 2025-12-24 19:46:28 +05:30
parent 8abb389712
commit 3c17706aff
3 changed files with 28 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

18
lib/vmpooler/api/queue_monitor.rb
View file

@ -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'

32
lib/vmpooler/pool_manager/auto_scaler.rb
View file

@ -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

12
lib/vmpooler/pool_manager/rate_provisioner.rb
View file

@ -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