update_script.py

#!/usr/bin/env python3
"""
KCTube Update Script
Tự động cập nhật KCTube từ Git repository
"""

import os
import sys
import subprocess
import json
import shutil
import time
from datetime import datetime

class KCTubeUpdater:
    def __init__(self):
        self.backup_dir = f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        self.config_file = "app_config.json"
        self.cache_file = "video_cache.json"
        
    def log(self, message, level="INFO"):
        """Log message với timestamp"""
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] {level}: {message}")
        
    def run_command(self, command, capture_output=True, timeout=300):
        """Chạy command và trả về kết quả"""
        try:
            result = subprocess.run(
                command,
                shell=True,
                capture_output=capture_output,
                text=True,
                timeout=timeout
            )
            return result
        except subprocess.TimeoutExpired:
            self.log(f"Command timed out: {command}", "ERROR")
            return None
        except Exception as e:
            self.log(f"Command failed: {command} - {str(e)}", "ERROR")
            return None
            
    def check_git_repository(self):
        """Kiểm tra xem có phải là git repository không"""
        self.log("Kiểm tra Git repository...")
        result = self.run_command("git status")
        if result and result.returncode == 0:
            self.log("✓ Đây là Git repository hợp lệ")
            return True
        else:
            self.log("✗ Không phải Git repository hoặc có lỗi", "ERROR")
            return False
            
    def create_backup(self):
        """Tạo backup cho các file quan trọng"""
        self.log("Tạo backup...")
        
        try:
            os.makedirs(self.backup_dir, exist_ok=True)
            
            # Backup config file
            if os.path.exists(self.config_file):
                shutil.copy2(self.config_file, os.path.join(self.backup_dir, self.config_file))
                self.log(f"✓ Đã backup {self.config_file}")
                
            # Backup cache file
            if os.path.exists(self.cache_file):
                shutil.copy2(self.cache_file, os.path.join(self.backup_dir, self.cache_file))
                self.log(f"✓ Đã backup {self.cache_file}")
                
            # Backup requirements.txt
            if os.path.exists("requirements.txt"):
                shutil.copy2("requirements.txt", os.path.join(self.backup_dir, "requirements.txt"))
                self.log("✓ Đã backup requirements.txt")
                
            self.log(f"✓ Backup hoàn tất tại: {self.backup_dir}")
            return True
            
        except Exception as e:
            self.log(f"✗ Lỗi khi tạo backup: {str(e)}", "ERROR")
            return False
            
    def check_git_status(self):
        """Kiểm tra trạng thái Git"""
        self.log("Kiểm tra trạng thái Git...")
        
        # Kiểm tra branch hiện tại
        result = self.run_command("git branch --show-current")
        if result and result.returncode == 0:
            current_branch = result.stdout.strip()
            self.log(f"Branch hiện tại: {current_branch}")
        else:
            self.log("Không thể xác định branch hiện tại", "WARNING")
            current_branch = "main"
            
        # Kiểm tra thay đổi local
        result = self.run_command("git status --porcelain")
        if result and result.stdout.strip():
            self.log("Có thay đổi local, sẽ stash...")
            return True, current_branch
        else:
            self.log("Không có thay đổi local")
            return False, current_branch
            
    def stash_changes(self):
        """Stash thay đổi local"""
        self.log("Stash thay đổi local...")
        result = self.run_command("git stash")
        if result and result.returncode == 0:
            self.log("✓ Đã stash thay đổi local")
            return True
        else:
            self.log("✗ Lỗi khi stash thay đổi", "ERROR")
            return False
            
    def fetch_updates(self):
        """Fetch cập nhật từ remote"""
        self.log("Fetch cập nhật từ remote...")
        result = self.run_command("git fetch origin")
        if result and result.returncode == 0:
            self.log("✓ Đã fetch cập nhật")
            return True
        else:
            self.log("✗ Lỗi khi fetch cập nhật", "ERROR")
            return False
            
    def check_updates_available(self, branch="main"):
        """Kiểm tra có cập nhật mới không"""
        self.log("Kiểm tra cập nhật mới...")
        result = self.run_command(f"git rev-list HEAD..origin/{branch} --count")
        if result and result.returncode == 0:
            commits_behind = int(result.stdout.strip())
            if commits_behind > 0:
                self.log(f"✓ Có {commits_behind} commit cần cập nhật")
                return True, commits_behind
            else:
                self.log("✓ Đã là phiên bản mới nhất")
                return False, 0
        else:
            self.log("✗ Không thể kiểm tra cập nhật", "ERROR")
            return False, 0
            
    def pull_updates(self, branch="main"):
        """Pull cập nhật mới"""
        self.log(f"Pull cập nhật từ origin/{branch}...")
        result = self.run_command(f"git pull origin {branch}")
        if result and result.returncode == 0:
            self.log("✓ Đã pull cập nhật thành công")
            return True
        else:
            self.log("✗ Lỗi khi pull cập nhật", "ERROR")
            return False
            
    def check_requirements_changed(self):
        """Kiểm tra requirements.txt có thay đổi không"""
        self.log("Kiểm tra thay đổi requirements.txt...")
        result = self.run_command("git diff HEAD~1 HEAD --name-only")
        if result and result.returncode == 0 and "requirements.txt" in result.stdout:
            self.log("✓ requirements.txt đã thay đổi")
            return True
        else:
            self.log("requirements.txt không thay đổi")
            return False
            
    def update_dependencies(self):
        """Cập nhật dependencies"""
        self.log("Cập nhật dependencies...")
        result = self.run_command("pip install -r requirements.txt")
        if result and result.returncode == 0:
            self.log("✓ Đã cập nhật dependencies")
            return True
        else:
            self.log("✗ Lỗi khi cập nhật dependencies", "ERROR")
            return False
            
    def update_yt_dlp(self):
        """Cập nhật yt-dlp"""
        self.log("Cập nhật yt-dlp...")
        result = self.run_command("pip install -U yt-dlp")
        if result and result.returncode == 0:
            self.log("✓ Đã cập nhật yt-dlp")
            return True
        else:
            self.log("✗ Lỗi khi cập nhật yt-dlp", "ERROR")
            return False
            
    def get_current_commit(self):
        """Lấy thông tin commit hiện tại"""
        result = self.run_command('git log -1 --pretty=format:"%h - %s (%cr)"')
        if result and result.returncode == 0:
            return result.stdout.strip()
        return "Unknown"
        
    def restore_stash(self):
        """Khôi phục stash"""
        self.log("Khôi phục stash...")
        result = self.run_command("git stash pop")
        if result and result.returncode == 0:
            self.log("✓ Đã khôi phục stash")
            return True
        else:
            self.log("✗ Lỗi khi khôi phục stash", "ERROR")
            return False
            
    def run_update(self):
        """Chạy toàn bộ quá trình update"""
        self.log("=== BẮT ĐẦU QUÁ TRÌNH CẬP NHẬT KCTube ===")
        
        # Bước 1: Kiểm tra Git repository
        if not self.check_git_repository():
            return False
            
        # Bước 2: Tạo backup
        if not self.create_backup():
            self.log("Tiếp tục mà không có backup...", "WARNING")
            
        # Bước 3: Kiểm tra trạng thái Git
        has_changes, current_branch = self.check_git_status()
        
        # Bước 4: Stash thay đổi nếu có
        if has_changes:
            if not self.stash_changes():
                return False
                
        # Bước 5: Fetch cập nhật
        if not self.fetch_updates():
            return False
            
        # Bước 6: Kiểm tra có cập nhật mới không
        has_updates, commits_behind = self.check_updates_available(current_branch)
        if not has_updates:
            self.log("Không có cập nhật mới")
            return True
            
        # Bước 7: Pull cập nhật
        if not self.pull_updates(current_branch):
            return False
            
        # Bước 8: Kiểm tra và cập nhật dependencies
        if self.check_requirements_changed():
            if not self.update_dependencies():
                self.log("Cảnh báo: Không thể cập nhật dependencies", "WARNING")
                
        # Bước 9: Cập nhật yt-dlp
        if not self.update_yt_dlp():
            self.log("Cảnh báo: Không thể cập nhật yt-dlp", "WARNING")
            
        # Bước 10: Khôi phục stash nếu có
        if has_changes:
            self.restore_stash()
            
        # Bước 11: Hiển thị kết quả
        current_commit = self.get_current_commit()
        self.log(f"=== CẬP NHẬT HOÀN TẤT ===")
        self.log(f"Commit hiện tại: {current_commit}")
        self.log(f"Số commit đã cập nhật: {commits_behind}")
        self.log(f"Backup được lưu tại: {self.backup_dir}")
        self.log("Vui lòng khởi động lại ứng dụng để áp dụng thay đổi")
        
        return True
        
    def rollback(self):
        """Rollback về trạng thái trước khi update"""
        self.log("=== ROLLBACK ===")
        
        # Khôi phục từ backup
        if os.path.exists(self.backup_dir):
            try:
                # Khôi phục config
                backup_config = os.path.join(self.backup_dir, self.config_file)
                if os.path.exists(backup_config):
                    shutil.copy2(backup_config, self.config_file)
                    self.log(f"✓ Đã khôi phục {self.config_file}")
                    
                # Khôi phục cache
                backup_cache = os.path.join(self.backup_dir, self.cache_file)
                if os.path.exists(backup_cache):
                    shutil.copy2(backup_cache, self.cache_file)
                    self.log(f"✓ Đã khôi phục {self.cache_file}")
                    
                self.log("✓ Rollback hoàn tất")
                return True
                
            except Exception as e:
                self.log(f"✗ Lỗi khi rollback: {str(e)}", "ERROR")
                return False
        else:
            self.log("✗ Không tìm thấy backup", "ERROR")
            return False

def main():
    """Main function"""
    updater = KCTubeUpdater()
    
    if len(sys.argv) > 1:
        if sys.argv[1] == "--rollback":
            success = updater.rollback()
        elif sys.argv[1] == "--help":
            print("""
KCTube Update Script

Usage:
    python update_script.py          # Cập nhật bình thường
    python update_script.py --rollback  # Rollback về trạng thái trước
    python update_script.py --help   # Hiển thị help

Options:
    --rollback    Rollback về trạng thái trước khi update
    --help        Hiển thị thông tin này
            """)
            return
        else:
            print("Option không hợp lệ. Sử dụng --help để xem hướng dẫn.")
            return
    else:
        success = updater.run_update()
        
    if success:
        print("\n✅ Cập nhật thành công!")
        sys.exit(0)
    else:
        print("\n❌ Cập nhật thất bại!")
        sys.exit(1)

if __name__ == "__main__":
    main()