move_uploaded_file批量上传多文件间歇性失效问题排查

First off, intermittent file upload issues are usually tied to unhandled edge cases, insufficient error checking, or subtle environmental factors. Let's break down the likely causes and a more robust solution for your three-file upload + MySQL update workflow.

Common Root Causes for Random Missing Files #

• Unchecked Upload Errors: PHP's file upload system returns error codes (like partial uploads, exceeded limits, or missing files) that might be ignored in your current code. These can trigger randomly due to network blips or server load.
• Filesystem Permission Flakiness: If the web server user doesn't have consistent write access to the target directory, some uploads might fail silently.
• Race Conditions or Overwrites: If filenames aren't unique, concurrent uploads could overwrite each other (though this is less likely if uploads are sequential).
• Server Configuration Limits: Hitting upload_max_filesize, post_max_size, or max_execution_time thresholds intermittently (e.g., if one file is slightly larger than allowed some of the time).

Optimized Implementation with Error Handling & Consistency #

The key fix here is to ensure all three files upload successfully before updating the database, and clean up partial uploads if anything fails. Here's a revised code structure:

// Define target directory (use an absolute path for reliability)
$targetDir = __DIR__ . '/uploads/';

// Step 1: Ensure target directory exists and is writable
if (!is_dir($targetDir)) {
    // Create directory with recursive permissions
    if (!mkdir($targetDir, 0755, true)) {
        die("Failed to create target directory. Check server permissions.");
    }
}
if (!is_writable($targetDir)) {
    die("Target directory is not writable. Update filesystem permissions for the web server user.");
}

// Step 2: Validate and process each file
$uploadedFiles = [];
$errors = [];

// Helper function to process a single file
function processFile($fileKey, $targetDir) {
    global $errors;
    $file = $_FILES[$fileKey];
    
    // Check for upload errors first
    if ($file['error'] !== UPLOAD_ERR_OK) {
        $errorMsg = match($file['error']) {
            UPLOAD_ERR_INI_SIZE => "File exceeds upload_max_filesize",
            UPLOAD_ERR_FORM_SIZE => "File exceeds form max size",
            UPLOAD_ERR_PARTIAL => "Partial file upload",
            UPLOAD_ERR_NO_FILE => "No file uploaded",
            default => "Unknown error (code: {$file['error']})"
        };
        $errors[] = "{$fileKey} failed: {$errorMsg}";
        return null;
    }
    
    // Generate a unique filename to avoid overwrites
    $uniqueName = uniqid('upload_', true) . '_' . basename($file['name']);
    $targetPath = $targetDir . $uniqueName;
    
    // Move the uploaded file
    if (move_uploaded_file($file['tmp_name'], $targetPath)) {
        return $uniqueName;
    } else {
        $errors[] = "Failed to move {$fileKey} to target directory.";
        return null;
    }
}

// Process each file
$uploadedFiles['A'] = processFile('fileA', $targetDir);
$uploadedFiles['B'] = processFile('fileB', $targetDir);
$uploadedFiles['C'] = processFile('fileC', $targetDir);

// Step 3: Check for errors and clean up partial uploads
if (!empty($errors)) {
    // Delete any successfully uploaded files to avoid partial state
    foreach ($uploadedFiles as $fileName) {
        if ($fileName && file_exists($targetDir . $fileName)) {
            unlink($targetDir . $fileName);
        }
    }
    
    // Log errors (use error_log() or a logging library for production)
    error_log("Upload failures: " . implode(' | ', $errors));
    die("Upload failed: " . implode(' ', $errors));
}

// Step 4: Update MySQL ONLY if all files uploaded successfully
try {
    // Use PDO for secure, prepared statements
    $pdo = new PDO(
        "mysql:host=your_host;dbname=your_db;charset=utf8mb4",
        "your_user",
        "your_password",
        [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
    );
    
    $stmt = $pdo->prepare("
        UPDATE your_table 
        SET fileA = :fileA, fileB = :fileB, fileC = :fileC 
        WHERE id = :record_id
    ");
    
    $stmt->execute([
        ':fileA' => $uploadedFiles['A'],
        ':fileB' => $uploadedFiles['B'],
        ':fileC' => $uploadedFiles['C'],
        ':record_id' => $cadguiUpdated // Assuming this is your record ID variable
    ]);
    
    echo "All files uploaded successfully, database updated.";
} catch (PDOException $e) {
    // Rollback file uploads if DB update fails
    foreach ($uploadedFiles as $fileName) {
        unlink($targetDir . $fileName);
    }
    error_log("Database update failed: " . $e->getMessage());
    die("Database update failed. Uploaded files have been rolled back.");
}

Additional Troubleshooting Tips #

• Enable PHP Error Logging: Check your server's PHP error log (usually in /var/log/apache2/ or /var/log/nginx/) for warnings about move_uploaded_file() or file permissions. This will give you exact details when an upload fails.
• Verify Server Limits: Double-check your php.ini settings for:
  • upload_max_filesize: Should be larger than the largest single file you're uploading.
  • post_max_size: Should be larger than the total size of all three files combined.
  • max_execution_time: Ensure it's long enough to handle large uploads.
• Test Permissions: Manually create a file in the target directory using the web server user (e.g., www-data on Apache) to confirm write access.
• Add Retry Logic: For network-related intermittent failures, you could add a limited retry mechanism for failed file moves (but avoid infinite loops!).

内容的提问来源于stack exchange，提问作者Anu