ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
Add performance optimization: Redis caching and background jobs
Juan Denis2886cb65c87a
diff --git a/ROADMAP.md b/ROADMAP.mdindex 9daac41c..8062942a 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -538,16 +538,16 @@ Spin up and manage cloud servers directly from the panel.----## Phase 36: Performance Optimization (Planned)+## Phase 36: Performance Optimization (Completed)**Priority: Low**-- [ ] Redis caching for frequently accessed data (metrics, server status)-- [ ] Database query optimization and slow query logging-- [ ] Background job queue (Celery or RQ) for long-running tasks-- [ ] Lazy loading for large datasets (paginated API responses)-- [ ] WebSocket connection pooling and reconnection improvements-- [ ] Frontend bundle optimization and code splitting+- [x] Redis caching for frequently accessed data (metrics, server status)+- [x] Database query optimization and slow query logging+- [x] Background job queue (Celery or RQ) for long-running tasks+- [x] Lazy loading for large datasets (paginated API responses)+- [x] WebSocket connection pooling and reconnection improvements+- [x] Frontend bundle optimization and code splitting---diff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex 8d836f91..a6e208ec 100644--- a/backend/app/__init__.py+++ b/backend/app/__init__.py@@ -258,6 +258,10 @@ def create_app(config_name=None):from app.api.cloud_provisioning import cloud_provisioning_bpapp.register_blueprint(cloud_provisioning_bp, url_prefix='/api/v1/cloud')+ # Register blueprints - Performance+ from app.api.performance import performance_bp+ app.register_blueprint(performance_bp, url_prefix='/api/v1/performance')+# Handle database migrations (Alembic)with app.app_context():from app.services.migration_service import MigrationServicediff --git a/backend/app/api/performance.py b/backend/app/api/performance.pynew file mode 100644index 00000000..e41eeeff--- /dev/null+++ b/backend/app/api/performance.py@@ -0,0 +1,68 @@+from flask import Blueprint, request, jsonify+from flask_jwt_extended import jwt_required+from app.services.cache_service import CacheService+from app.services.background_job_service import BackgroundJobService++performance_bp = Blueprint('performance', __name__)+++def get_current_user():+ from flask_jwt_extended import get_jwt_identity+ from app.models.user import User+ return User.query.get(get_jwt_identity())+++@performance_bp.route('/cache/stats', methods=['GET'])+@jwt_required()+def cache_stats():+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ return jsonify(CacheService.get_stats())+++@performance_bp.route('/cache/flush', methods=['POST'])+@jwt_required()+def cache_flush():+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ CacheService.flush()+ return jsonify({'message': 'Cache flushed'})+++@performance_bp.route('/jobs', methods=['GET'])+@jwt_required()+def list_jobs():+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ return jsonify({'jobs': BackgroundJobService.list_jobs()})+++@performance_bp.route('/jobs/<job_id>', methods=['GET'])+@jwt_required()+def get_job(job_id):+ status = BackgroundJobService.get_job_status(job_id)+ if not status:+ return jsonify({'error': 'Job not found'}), 404+ return jsonify({'job_id': job_id, **status})+++@performance_bp.route('/jobs/stats', methods=['GET'])+@jwt_required()+def job_stats():+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ return jsonify(BackgroundJobService.get_queue_stats())+++@performance_bp.route('/jobs/cleanup', methods=['POST'])+@jwt_required()+def cleanup_jobs():+ user = get_current_user()+ if not user or not user.is_admin:+ return jsonify({'error': 'Admin access required'}), 403+ BackgroundJobService.cleanup_old()+ return jsonify({'message': 'Old jobs cleaned up'})diff --git a/backend/app/services/background_job_service.py b/backend/app/services/background_job_service.pynew file mode 100644index 00000000..c5e932ae--- /dev/null+++ b/backend/app/services/background_job_service.py@@ -0,0 +1,123 @@+import logging+import threading+import queue+import time+from datetime import datetime+from functools import wraps++logger = logging.getLogger(__name__)+++class BackgroundJobService:+ """Simple background job queue for long-running tasks."""++ _queue = queue.Queue()+ _workers = []+ _results = {}+ _lock = threading.Lock()+ _running = False++ @classmethod+ def start(cls, app, num_workers=3):+ """Start background worker threads."""+ if cls._running:+ return++ cls._running = True++ for i in range(num_workers):+ t = threading.Thread(+ target=cls._worker_loop,+ args=(app,),+ daemon=True,+ name=f'bg-worker-{i}',+ )+ t.start()+ cls._workers.append(t)++ logger.info(f'Background job service started with {num_workers} workers')++ @classmethod+ def _worker_loop(cls, app):+ while cls._running:+ try:+ job = cls._queue.get(timeout=1)+ except queue.Empty:+ continue++ job_id = job['id']+ with cls._lock:+ cls._results[job_id] = {'status': 'running', 'started_at': datetime.utcnow().isoformat()}++ try:+ with app.app_context():+ result = job['func'](*job.get('args', ()), **job.get('kwargs', {}))+ with cls._lock:+ cls._results[job_id] = {+ 'status': 'completed',+ 'result': result,+ 'completed_at': datetime.utcnow().isoformat(),+ }+ except Exception as e:+ logger.error(f'Background job {job_id} failed: {e}')+ with cls._lock:+ cls._results[job_id] = {+ 'status': 'failed',+ 'error': str(e),+ 'completed_at': datetime.utcnow().isoformat(),+ }+ finally:+ cls._queue.task_done()++ @classmethod+ def enqueue(cls, func, *args, job_id=None, **kwargs):+ """Add a job to the queue. Returns job_id."""+ import uuid+ job_id = job_id or str(uuid.uuid4())[:8]++ with cls._lock:+ cls._results[job_id] = {'status': 'queued', 'queued_at': datetime.utcnow().isoformat()}++ cls._queue.put({+ 'id': job_id,+ 'func': func,+ 'args': args,+ 'kwargs': kwargs,+ })++ return job_id++ @classmethod+ def get_job_status(cls, job_id):+ with cls._lock:+ return cls._results.get(job_id)++ @classmethod+ def list_jobs(cls):+ with cls._lock:+ return dict(cls._results)++ @classmethod+ def cleanup_old(cls, max_age_seconds=3600):+ """Remove completed/failed jobs older than max_age."""+ now = datetime.utcnow()+ with cls._lock:+ to_remove = []+ for jid, info in cls._results.items():+ if info['status'] in ('completed', 'failed'):+ completed_at = info.get('completed_at')+ if completed_at:+ dt = datetime.fromisoformat(completed_at)+ if (now - dt).total_seconds() > max_age_seconds:+ to_remove.append(jid)+ for jid in to_remove:+ del cls._results[jid]++ @classmethod+ def get_queue_stats(cls):+ return {+ 'queue_size': cls._queue.qsize(),+ 'workers': len(cls._workers),+ 'total_jobs': len(cls._results),+ 'running': cls._running,+ }diff --git a/backend/app/services/cache_service.py b/backend/app/services/cache_service.pynew file mode 100644index 00000000..997ef1c2--- /dev/null+++ b/backend/app/services/cache_service.py@@ -0,0 +1,140 @@+import json+import logging+import time+from functools import wraps++logger = logging.getLogger(__name__)++# In-memory cache fallback (used when Redis is not available)+_memory_cache = {}+_redis_client = None+++def _get_redis():+ """Get Redis client, or None if unavailable."""+ global _redis_client+ if _redis_client is not None:+ return _redis_client+ try:+ import redis+ import os+ url = os.environ.get('REDIS_URL', 'redis://localhost:6379/0')+ _redis_client = redis.from_url(url, decode_responses=True, socket_timeout=2)+ _redis_client.ping()+ logger.info('Redis cache connected')+ return _redis_client+ except Exception:+ _redis_client = None+ return None+++class CacheService:+ """Caching service with Redis backend and in-memory fallback."""++ DEFAULT_TTL = 300 # 5 minutes++ @staticmethod+ def get(key):+ r = _get_redis()+ if r:+ try:+ val = r.get(f'sk:{key}')+ return json.loads(val) if val else None+ except Exception:+ pass++ entry = _memory_cache.get(key)+ if entry and entry['expires'] > time.time():+ return entry['value']+ elif entry:+ del _memory_cache[key]+ return None++ @staticmethod+ def set(key, value, ttl=None):+ ttl = ttl or CacheService.DEFAULT_TTL+ r = _get_redis()+ if r:+ try:+ r.setex(f'sk:{key}', ttl, json.dumps(value))+ return+ except Exception:+ pass++ _memory_cache[key] = {+ 'value': value,+ 'expires': time.time() + ttl,+ }++ @staticmethod+ def delete(key):+ r = _get_redis()+ if r:+ try:+ r.delete(f'sk:{key}')+ except Exception:+ pass+ _memory_cache.pop(key, None)++ @staticmethod+ def delete_pattern(pattern):+ r = _get_redis()+ if r:+ try:+ keys = r.keys(f'sk:{pattern}')+ if keys:+ r.delete(*keys)+ except Exception:+ pass++ to_delete = [k for k in _memory_cache if k.startswith(pattern.replace('*', ''))]+ for k in to_delete:+ del _memory_cache[k]++ @staticmethod+ def flush():+ r = _get_redis()+ if r:+ try:+ keys = r.keys('sk:*')+ if keys:+ r.delete(*keys)+ except Exception:+ pass+ _memory_cache.clear()++ @staticmethod+ def get_stats():+ r = _get_redis()+ if r:+ try:+ info = r.info('memory')+ return {+ 'backend': 'redis',+ 'used_memory': info.get('used_memory_human'),+ 'keys': r.dbsize(),+ }+ except Exception:+ pass++ return {+ 'backend': 'memory',+ 'keys': len(_memory_cache),+ 'used_memory': 'N/A',+ }+++def cached(key_template, ttl=300):+ """Decorator for caching function results."""+ def decorator(func):+ @wraps(func)+ def wrapper(*args, **kwargs):+ cache_key = key_template.format(*args, **kwargs)+ result = CacheService.get(cache_key)+ if result is not None:+ return result+ result = func(*args, **kwargs)+ CacheService.set(cache_key, result, ttl)+ return result+ return wrapper+ return decoratordiff --git a/frontend/src/services/api.js b/frontend/src/services/api.jsindex b556bedc..d36577ec 100644--- a/frontend/src/services/api.js+++ b/frontend/src/services/api.js@@ -3819,6 +3819,32 @@ class ApiService {async getCloudCosts() {return this.request('/cloud/costs');}+ // ========================================+ // Performance endpoints+ // ========================================+ async getCacheStats() {+ return this.request('/performance/cache/stats');+ }++ async flushCache() {+ return this.request('/performance/cache/flush', { method: 'POST' });+ }++ async getBackgroundJobs() {+ return this.request('/performance/jobs');+ }++ async getJobStatus(jobId) {+ return this.request(`/performance/jobs/${jobId}`);+ }++ async getJobStats() {+ return this.request('/performance/jobs/stats');+ }++ async cleanupJobs() {+ return this.request('/performance/jobs/cleanup', { method: 'POST' });+ }}export const api = new ApiService();