Advanced File Manager

✏️ Mengedit: backup_realtime_partial.py

import argparse
import os
import re
import time
from pathlib import Path
from typing import List, Optional

from app.config import bart_jobs_folder
from app.errors.error_codes import ErrorCode
from app.errors.exceptions import BartError
from app.utils.args_validations import *
from app.utils.job_activity_logger import JobActivityLogger
from app.utils.utility_functions import measure_time, cleanup_backup_folder, run_sudo_command_str, \
    run_sudo_command, create_backup_tar_cli, read_homedir, does_path_exists, is_directory

activity_logger: JobActivityLogger = None

# ------------------------ Core Functions ------------------------

MYSQL_COMMAND_DB_CREATE = "mysqldump --no-create-info --no-data --databases <db_name> > <output_dir><db_name>.create"
MYSQL_COMMAND_TABLE_CREATE_DUMP = "mysqldump --no-create-db --databases <db_name> > <output_dir><db_name>.sql"

def create_empty_folder(username: str, cbs_id: int) -> str:
    backup_folder = f"{bart_jobs_folder}/job_{cbs_id}/{username}_partial_{cbs_id}"
    homedir_folder = os.path.join(backup_folder, "homedir")
    mysql_folder = os.path.join(backup_folder, "mysql")

os.makedirs(homedir_folder, exist_ok=True)
    os.makedirs(mysql_folder, exist_ok=True)

activity_logger.success(f"Created backup folder: {backup_folder}")
    activity_logger.success(f"Created homedir folder: {homedir_folder}")
    activity_logger.success(f"Created mysql folder: {mysql_folder}")

return backup_folder

def _normalize_excludes_for_base(exclude_paths: List[str], base: str) -> List[str]:
    """
    Make excludes relative to the given base path.
    Examples:
      base='public_html', exclude='public_html/wp-content' -> 'wp-content'
      base='public_html', exclude='public_html' -> '' (exclude entire base)
      base='public_html/blog', exclude='public_html/blog/wp-admin' -> 'wp-admin'
    """
    normed = []
    base_clean = (base or "").strip('/')
    for e in (exclude_paths or []):
        if not e:
            continue
        e_clean = e.lstrip('/')
        if base_clean and (e_clean == base_clean or e_clean.startswith(base_clean + '/')):
            e_rel = e_clean[len(base_clean):].lstrip('/')  # '' if excluding the whole base
        else:
            e_rel = e_clean
        normed.append(e_rel)
    return normed

def _build_rsync_ex_args(exclude_paths: List[str], base: str) -> List[str]:
    """
    Build rsync-specific exclude flags anchored at the transfer root.
    If normalized exclude is '' -> exclude everything under the base.
    """
    normed = _normalize_excludes_for_base(exclude_paths or [], base)
    rsync_args: List[str] = []

if not normed:
        return rsync_args

for e in normed:
        if e == "":
            # exclude entire sync root
            rsync_args.extend(["--exclude=/**/*", "--exclude=/"])
        else:
            # exclude a directory/file under base
            rsync_args.extend([f"--exclude=/{e}/***", f"--exclude=/{e}/"])
    return rsync_args

@measure_time
def copy_paths(backup_folder: str, homedir: str, paths: list, exclude_paths: Optional[List[str]] = None, skip_missing_paths: bool = False):
    successful_paths = []
    skipped_paths = []
    
    for path in paths or []:
        base = path.strip('/')

source_path = os.path.join(homedir, base)
        destination_path = os.path.join(backup_folder, "homedir", base)

if not does_path_exists(source_path):
            msg = f"Path {source_path} does not exist in the filesystem"
            activity_logger.warn(msg)
            skipped_paths.append(path)
            
            if skip_missing_paths:
                activity_logger.info(f"Skipping missing path {path} and continuing backup")
                continue
            else:
                # If skip_missing_paths is False, raise error
                activity_logger.error(f"{msg}, exiting.")
                raise BartError(ErrorCode.PATH_NOT_FOUND, msg)

os.makedirs(os.path.dirname(destination_path), exist_ok=True)

# Build rsync-specific excludes relative to this base
        rsync_ex = _build_rsync_ex_args(exclude_paths or [], base)
        if rsync_ex:
            activity_logger.info(f"Excludes (rsync): {' '.join(rsync_ex)}")

try:
            if is_directory(source_path):
                rsync_cmd = [
                    "rsync", "-a",
                    "--homedir", homedir,
                    *rsync_ex,
                    f"{source_path}/", f"{destination_path}/"
                ]
                run_sudo_command(rsync_cmd)
            else:
                # For single files just use rsync
                rsync_cmd = [
                    "rsync", "-a",
                    "--homedir", homedir,
                    source_path, destination_path
                ]
                run_sudo_command(rsync_cmd)

activity_logger.success(f"Copied {path} to {destination_path}")
            successful_paths.append(path)

except Exception as e:
            msg = f"Failed to copy {source_path} → {destination_path}: {e}"
            activity_logger.error(msg)
            raise BartError(ErrorCode.RSYNC_FAILED_DURING_BACKUP, msg)
    
    return successful_paths, skipped_paths

@measure_time
def copy_databases(backup_folder: str, databases: list, skip_missing_databases: bool = False):
    output_dir = os.path.join(backup_folder, "mysql") + "/"
    os.makedirs(output_dir, exist_ok=True)
    successful_dbs = []
    skipped_dbs = []
    
    for db in databases:
        activity_logger.note(f"Creating dump for db {db}")
        mysqldump_db_create_cmd = MYSQL_COMMAND_DB_CREATE.replace("<db_name>", db).replace(
            "<output_dir>", output_dir)
        mysqldump_table_create_dump_cmd = MYSQL_COMMAND_TABLE_CREATE_DUMP.replace("<db_name>",
                                                                                  db).replace(
            "<output_dir>", output_dir)
        try:
            run_sudo_command_str(mysqldump_db_create_cmd)
            run_sudo_command_str(mysqldump_table_create_dump_cmd)
            activity_logger.success(f"Database {db} dumped to {output_dir}")
            successful_dbs.append(db)
        except Exception as e:
            is_unknown_db = "Unknown database" in str(e)
            msg = f"Failed to dump database {db}: {e}"
            
            if is_unknown_db:
                activity_logger.warn(f"Database {db} not found on server")
                skipped_dbs.append(db)
                
                if skip_missing_databases:
                    activity_logger.info(f"Skipping missing database {db} and continuing backup")
                    continue
                # If skip_missing_databases is False, fall through to error handling below
                error_code = ErrorCode.DB_NOT_FOUND
            else:
                # Other errors (not missing database) - always fail
                error_code = ErrorCode.SQL_DUMP_CMD_FAILED
            
            # Common error handling for both missing and other database errors
            activity_logger.error(f"{msg}. Cleaning up the jobs folder and exiting.")
            cleanup_backup_folder(backup_folder)
            activity_logger.info(f"Cleaned backup folder {backup_folder}")
            raise BartError(error_code, msg)
    
    return successful_dbs, skipped_dbs

# This method cannot be pulled in a common class since logger obj is only available here
def log_time_taken(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        elapsed_time = end_time - start_time
        activity_logger.info(f"[TOTAL TIME] Script completed in {elapsed_time:.3f} seconds")
        return result
    return wrapper

@log_time_taken
def backup(username: str,
           paths: list,
           databases: list,
           cbs_id: int,
           exclude_paths: Optional[List[str]] = None,
           skip_missing_databases: bool = False,
           skip_missing_paths: bool = False,
           is_cli: bool = False):
    set_job_logger(cbs_id, is_cli)
    activity_logger.info(f"<======== Starting Realtime Partial Backup ========>")
    backup_folder = create_empty_folder(username, cbs_id)
    homedir = read_homedir(username)
    if not homedir:
        error_msg = f"User {username} does not exist on the server."
        activity_logger.error(error_msg)
        raise BartError(ErrorCode.USER_NOT_FOUND, error_msg)
    
    backed_up_paths, skipped_paths = copy_paths(backup_folder, homedir, paths, exclude_paths=exclude_paths, skip_missing_paths=skip_missing_paths)
    backed_up_dbs, skipped_dbs = copy_databases(backup_folder, databases, skip_missing_databases=skip_missing_databases)
    
    if skipped_paths:
        activity_logger.warn(f"Skipped paths: {', '.join(skipped_paths)}")
    if backed_up_paths:
        activity_logger.success(f"Successfully backed up paths: {', '.join(backed_up_paths)}")
    
    if skipped_dbs:
        activity_logger.warn(f"Skipped databases: {', '.join(skipped_dbs)}")
    if backed_up_dbs:
        activity_logger.success(f"Successfully backed up databases: {', '.join(backed_up_dbs)}")

generate_mysql_sql_file(backup_folder, username)

output_tarfile_path = create_backup_tar_cli(backup_folder)
    activity_logger.success(f"Created tarfile {output_tarfile_path}")
    cleanup_backup_folder(backup_folder)
    activity_logger.success(f"Cleaned backup folder {backup_folder}")
    return output_tarfile_path, backed_up_paths, skipped_paths, backed_up_dbs, skipped_dbs

def generate_mysql_sql_file(backup_folder, username):
    # Generate mysql.sql file with user grants
    mysql_sql_path = os.path.join(backup_folder, "mysql.sql")
    try:
        activity_logger.info(f"Starting generating mysql.sql")
        generate_mysql_sql(cpuser=username, output_path=mysql_sql_path)
        activity_logger.info(f"Generated mysql.sql for {username} location: {mysql_sql_path}")
    except Exception as e:
        activity_logger.warn(f"Failed to generate mysql.sql: {e}. Continuing backup without mysql.sql file.")

def set_job_logger(job_id, is_cli):
    global activity_logger
    activity_logger = JobActivityLogger(job_id, echo_to_stdout=is_cli)

def escape_dbname_in_grant(line: str) -> str:
    """
    Escape underscores in database names inside backticks,
    exactly like cPanel.
    Example: `vqolkate_WPFVR` -> `vqolkate\_WPFVR`
    Only database names (before .*) are escaped.
    Normalizes escaping: first unescapes any existing escapes, then escapes all underscores.
    """
    def repl(match):
        dbname = match.group(1)
        # First, unescape any existing escaped underscores (normalize)
        # Use regex to replace any sequence of backslashes followed by underscore with just underscore
        # This handles cases where MySQL already escaped it (single or multiple backslashes)
        dbname_normalized = re.sub(r'\\+_', '_', dbname)
        # Then escape all underscores (ensures exactly one escape)
        # Build the escaped string character by character to avoid double-escaping issues
        dbname_escaped = ''
        for char in dbname_normalized:
            if char == '_':
                dbname_escaped += '\\_'
            else:
                dbname_escaped += char
        return f"`{dbname_escaped}`"

# Only match DB names in backticks that appear before .*
    pattern = r"`([^`]+)`(?=\.\*)"
    return re.sub(pattern, repl, line)

def get_cp_mysql_users(cpuser: str):
    """
    Return list of (user, host, password_hash) tuples for all MySQL users
    belonging to the cPanel account.
    Uses MySQL wrapper for database commands.
    """
    query = f"SELECT User, Host, authentication_string FROM mysql.user WHERE User LIKE '{cpuser}%';"
    try:
        result = run_sudo_command(["mysql", "-e", query])
        if result is None:
            activity_logger.error("Error querying mysql.user: No output returned")
            return []
    except Exception as e:
        activity_logger.error(f"Error querying mysql.user: {e}")
        return []

users = []
    lines = result.splitlines()
    # Skip header line if present
    start_idx = 1 if lines and "User" in lines[0] else 0
    for line in lines[start_idx:]:
        parts = line.split("\t")
        if len(parts) == 3:
            user, host, pw_hash = parts
            users.append((user.strip(), host.strip(), pw_hash.strip()))
    return users

def build_grants_for_user(user: str, host: str):
    """
    Return a list of GRANT statements for this user@host,
    properly formatted for cPanel.
    Uses MySQL wrapper for database commands.
    """
    try:
        result = run_sudo_command(["mysql", "-e", f"SHOW GRANTS FOR '{user}'@'{host}';"])
        if result is None:
            raise RuntimeError(f"Error fetching grants for {user}@{host}: No output returned")
    except Exception as e:
        raise RuntimeError(f"Error fetching grants for {user}@{host}: {e}")

grants = []
    for line in result.splitlines():
        line = line.strip()
        if not line:
            continue
        # Skip "Grants for user@host;" header line explicitly
        if line.upper().startswith("GRANTS FOR"):
            continue
        # Skip header lines or non-GRANT lines
        if not line.upper().startswith("GRANT"):
            continue
        if line.upper().startswith("GRANT USAGE"):
            # keep USAGE grant as-is
            grants.append(line)
            continue

# Escape underscores in database names
        line = escape_dbname_in_grant(line)

# Ensure usernames and hosts are in single quotes
        line = re.sub(r"`([^`]+)`@`([^`]+)`", r"'\1'@'\2'", line)

# Add semicolon if missing
        if not line.endswith(";"):
            line += ";"

grants.append(line)

return grants

def generate_mysql_sql(cpuser: str, output_path: str):
    """
    Generate mysql.sql file with user grants for the cPanel user.
    Uses MySQL wrapper for all database commands.
    """
    output = []

users = get_cp_mysql_users(cpuser)
    if not users:
        activity_logger.warn(f"No MySQL users found for {cpuser}, skipping mysql.sql generation")
        return

for user, host, pw_hash in users:
        # Step 1: USAGE grants with password hash
        if pw_hash:
            output.append(
                f"GRANT USAGE ON *.* TO '{user}'@'{host}' IDENTIFIED BY PASSWORD '{pw_hash}';"
            )

# Step 2: DB-specific grants
        try:
            grants = build_grants_for_user(user, host)
            for g in grants:
                # skip USAGE since we already added it
                if g.upper().startswith("GRANT USAGE"):
                    continue
                output.append(g)
        except Exception as e:
            activity_logger.warn(f"Failed to fetch grants for {user}@{host}: {e}")
            continue

# Step 3: write to file
    if output:
        Path(output_path).write_text("\n".join(output) + "\n")
        activity_logger.success(f"Created mysql.sql at {output_path} for cPanel user {cpuser}")
    else:
        activity_logger.warn(f"No grants found for {cpuser}, mysql.sql not created")

def main():
    parser = argparse.ArgumentParser(description='Backup script for docroot and database data for realtime backup.')
    parser.add_argument('--username', type=validate_username, required=True, help='Specify the username')
    parser.add_argument('--paths', nargs='+', help='Space-separated paths (relative to homedir), e.g. public_html')
    parser.add_argument('--exclude-paths', nargs='+',
                        help='Space-separated paths to exclude (relative to each path you copy), '
                             'e.g. public_html/wp-admin public_html/wp-content')
    parser.add_argument('--databases', nargs='+', help='Space-separated database names')
    parser.add_argument('--cbs_id', type=validate_cbs_id, required=True, help='Specify the CBS Id')

args = parser.parse_args()

paths = args.paths
    databases = args.databases
    exclude_paths = args.exclude_paths

validate_docroots(paths)
    validate_databases(databases)
    if exclude_paths:
        validate_docroots(exclude_paths)

backup(args.username, paths, databases, args.cbs_id, exclude_paths=exclude_paths, skip_missing_databases=False, is_cli=True)

if __name__ == "__main__":
    main()

# Example:
# python backup_realtime_partial.py \
#   --username jsoiexte \
#   --paths public_html \
#   --exclude-paths public_html/wp-admin public_html/wp-content \
#   --databases jsoiexte_WPA00 \
#   --cbs_id 1235

❌ Batal

Nama	Ukuran	Dimodifikasi	Permission	Aksi
📁 __pycache__	-	2026-06-23 12:24	0755
📁 api	-	2026-06-23 12:24	0755
📁 auth_framework	-	2026-06-23 12:24	0755
📁 configs	-	2026-06-23 12:24	0755
📁 errors	-	2026-06-23 12:24	0755
📁 multi_backups	-	2026-06-23 12:24	0755
📁 utils	-	2026-06-23 12:24	0755
📁 zfs_backup_delete	-	2026-06-23 12:24	0755
📁 zfs_backup_download	-	2026-06-23 12:24	0755
💻 __init__.py	0 B	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 backup_historic_account_full_partial.py	13.3 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 backup_manual_full.py	4.5 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 backup_manual_partial.py	8.5 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 backup_realtime_account_cpanel.py	4.4 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 backup_realtime_account_destiny.py	37.7 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 backup_realtime_full.py	4.7 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 backup_realtime_partial.py	16.3 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 config.py	432 B	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 main.py	2.3 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 mount_bv_and_get_backup_data.py	4.9 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 restore_account_cpanel.py	4.5 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 restore_account_destiny.py	41.4 KB	2026-06-23 12:24	0644	✏️ Edit ⬇
💻 restore_full_partial.py	29.3 KB	2026-06-23 12:24	0644	✏️ Edit ⬇

📂 Advanced File Manager

✏️ Mengedit: backup_realtime_partial.py

✍️ Rename: