-
-
-
switch to basic browser
@@ -179,43 +180,40 @@
(function() {
var CONFIG = {
MAX_RETRIES: 3,
- RETRY_DELAY_BASE: 1000,
- RETRY_HTTP_CODES: [0, 408, 500, 502, 503, 504],
- SPEED_SMOOTHING_FACTOR: 0.3,
- MIN_SPEED_SAMPLES: 3,
- PROGRESS_UPDATE_MIN_INTERVAL: 50,
- TIMEOUT: 300000
+ INITIAL_RETRY_DELAY: 1000,
+ MAX_RETRY_DELAY: 30000,
+ UPLOAD_TIMEOUT: 300000,
+ SPEED_WINDOW_SIZE: 10,
+ ETA_MIN_SAMPLES: 3,
+ RETRYABLE_STATUSES: [0, 408, 425, 429, 500, 502, 503, 504]
};
- var UI = {
+ var state = {
progressDiv: null,
progressBar: null,
progressPercent: null,
- progressSpeed: null,
+ progressDetails: null,
progressEta: null,
- progressRemaining: null,
progressStatus: null,
progressFileinfo: null,
+ progressSizefmt: null,
resultDiv: null,
form: null,
submitBtn: null,
- fileInput: null
- };
-
- var uploadState = {
+ fileInput: null,
currentFiles: [],
currentFileIndex: 0,
totalFilesSize: 0,
- isUploading: false,
- shouldCancel: false
- };
-
- var progressTracker = {
- lastUpdateTime: 0,
- lastLoadedBytes: 0,
- smoothedSpeed: 0,
+ currentXhr: null,
+ isCancelled: false,
+ uploadStartTime: 0,
+ currentRetry: 0,
speedSamples: [],
- uploadStartTime: 0
+ lastLoaded: 0,
+ lastSampleTime: 0,
+ animationFrame: null,
+ smoothedPercent: 0,
+ targetPercent: 0
};
function formatSize(bytes) {
@@ -227,7 +225,7 @@
}
function formatSpeed(bytesPerSec) {
- if (bytesPerSec === 0) return '0 B/s';
+ if (bytesPerSec === 0 || !isFinite(bytesPerSec)) return '0 B/s';
var k = 1024,
sizes = ['B/s', 'KB/s', 'MB/s', 'GB/s'],
i = Math.floor(Math.log(bytesPerSec) / Math.log(k));
@@ -235,155 +233,38 @@
}
function formatDuration(seconds) {
- if (!isFinite(seconds) || seconds < 0) return '--:--';
+ if (!isFinite(seconds) || seconds < 0) return 'calculating...';
+ if (seconds === 0) return 'done';
- seconds = Math.ceil(seconds);
+ seconds = Math.round(seconds);
if (seconds < 60) {
return seconds + 's';
} else if (seconds < 3600) {
- var mins = Math.floor(seconds / 60);
- var secs = seconds % 60;
- return mins + 'm ' + secs + 's';
+ var m = Math.floor(seconds / 60);
+ var s = seconds % 60;
+ return m + 'm ' + s + 's';
} else {
- var hours = Math.floor(seconds / 3600);
- var mins = Math.floor((seconds % 3600) / 60);
- return hours + 'h ' + mins + 'm';
+ var h = Math.floor(seconds / 3600);
+ var m = Math.floor((seconds % 3600) / 60);
+ var s = seconds % 60;
+ return h + 'h ' + m + 'm ' + s + 's';
}
}
- function initProgressTracker() {
- progressTracker = {
- lastUpdateTime: Date.now(),
- lastLoadedBytes: 0,
- smoothedSpeed: 0,
- speedSamples: [],
- uploadStartTime: Date.now()
- };
+ function formatTime(ms) {
+ var date = new Date(ms);
+ return date.toLocaleTimeString();
}
- function calculateSpeed(loadedBytes, totalBytes) {
- var now = Date.now();
- var timeDiff = (now - progressTracker.lastUpdateTime) / 1000;
+ function isRetryableError(xhr) {
+ var status = xhr.status;
- if (timeDiff <= 0) {
- return progressTracker.smoothedSpeed;
- }
-
- var bytesDiff = loadedBytes - progressTracker.lastLoadedBytes;
- var instantSpeed = bytesDiff / timeDiff;
-
- progressTracker.speedSamples.push(instantSpeed);
- if (progressTracker.speedSamples.length > 10) {
- progressTracker.speedSamples.shift();
- }
-
- if (progressTracker.speedSamples.length >= CONFIG.MIN_SPEED_SAMPLES) {
- var avgSpeed = progressTracker.speedSamples.reduce(function(a, b) { return a + b; }, 0) /
- progressTracker.speedSamples.length;
-
- if (progressTracker.smoothedSpeed === 0) {
- progressTracker.smoothedSpeed = avgSpeed;
- } else {
- progressTracker.smoothedSpeed =
- CONFIG.SPEED_SMOOTHING_FACTOR * avgSpeed +
- (1 - CONFIG.SPEED_SMOOTHING_FACTOR) * progressTracker.smoothedSpeed;
- }
- }
-
- progressTracker.lastUpdateTime = now;
- progressTracker.lastLoadedBytes = loadedBytes;
-
- return progressTracker.smoothedSpeed;
- }
-
- function calculateETA(loadedBytes, totalBytes, speed) {
- if (speed <= 0 || loadedBytes <= 0) {
- return Infinity;
- }
- var remainingBytes = totalBytes - loadedBytes;
- return remainingBytes / speed;
- }
-
- function showProgress(show) {
- if (UI.progressDiv) {
- UI.progressDiv.style.display = show ? 'block' : 'none';
- }
- }
-
- function showResult(success, message) {
- if (UI.resultDiv) {
- UI.resultDiv.style.display = 'block';
- UI.resultDiv.style.background = success ? '#050' : '#500';
- UI.resultDiv.style.color = '#fff';
- UI.resultDiv.innerHTML = message;
- }
- }
-
- function hideResult() {
- if (UI.resultDiv) {
- UI.resultDiv.style.display = 'none';
- }
- }
-
- function updateProgress(loaded, total, forceUpdate) {
- if (!UI.progressBar || !UI.progressPercent) return;
-
- var now = Date.now();
- if (!forceUpdate && now - progressTracker.lastUpdateTime < CONFIG.PROGRESS_UPDATE_MIN_INTERVAL) {
- return;
- }
-
- var percent = total > 0 ? (loaded / total * 100) : 0;
- UI.progressBar.style.width = percent + '%';
- UI.progressPercent.textContent = percent.toFixed(1) + '%';
-
- var speed = calculateSpeed(loaded, total);
- var eta = calculateETA(loaded, total, speed);
-
- if (UI.progressSpeed) {
- UI.progressSpeed.textContent = formatSpeed(speed);
+ if (CONFIG.RETRYABLE_STATUSES.indexOf(status) !== -1) {
+ return true;
}
- if (UI.progressEta) {
- UI.progressEta.textContent = 'ETA: ' + formatDuration(eta);
- }
- }
-
- function setStatus(text) {
- if (UI.progressStatus) {
- UI.progressStatus.textContent = text;
- }
- }
-
- function setFileinfo(text) {
- if (UI.progressFileinfo) {
- UI.progressFileinfo.textContent = text;
- }
- }
-
- function updateRemainingFiles() {
- if (UI.progressRemaining) {
- var remaining = uploadState.currentFiles.length - uploadState.currentFileIndex - 1;
- UI.progressRemaining.textContent =
- 'File ' + (uploadState.currentFileIndex + 1) +
- '/' + uploadState.currentFiles.length +
- (remaining > 0 ? ' (' + remaining + ' remaining)' : '');
- }
- }
-
- function setFormEnabled(enabled) {
- if (UI.submitBtn) {
- UI.submitBtn.disabled = !enabled;
- UI.submitBtn.value = enabled ? 'start upload' : 'uploading...';
- }
- if (UI.fileInput) {
- UI.fileInput.disabled = !enabled;
- }
- }
-
- function isRetryableError(status, responseText) {
- if (CONFIG.RETRY_HTTP_CODES.indexOf(status) !== -1) {
+ if (status === 0) {
return true;
}
@@ -391,275 +272,478 @@
return true;
}
- if (status === 200 && responseText) {
- var lowerText = responseText.toLowerCase();
- if (lowerText.indexOf('error') !== -1 ||
- lowerText.indexOf('timeout') !== -1 ||
- lowerText.indexOf('failed') !== -1) {
- return true;
- }
- }
-
return false;
}
- function shouldRetryImmediately(status) {
- return status === 0 || status === 408 || status === 503;
+ function calculateRetryDelay(retryCount) {
+ var delay = CONFIG.INITIAL_RETRY_DELAY * Math.pow(2, retryCount);
+ var jitter = delay * 0.2 * (Math.random() - 0.5);
+ delay = delay + jitter;
+ return Math.min(delay, CONFIG.MAX_RETRY_DELAY);
+ }
+
+ function resetSpeedTracking() {
+ state.speedSamples = [];
+ state.lastLoaded = 0;
+ state.lastSampleTime = 0;
+ }
+
+ function addSpeedSample(loaded, total, currentTime) {
+ if (state.lastSampleTime === 0) {
+ state.lastLoaded = loaded;
+ state.lastSampleTime = currentTime;
+ return;
+ }
+
+ var timeDiff = (currentTime - state.lastSampleTime) / 1000;
+ var bytesDiff = loaded - state.lastLoaded;
+
+ if (timeDiff > 0 && bytesDiff >= 0) {
+ var speed = bytesDiff / timeDiff;
+
+ state.speedSamples.push({
+ speed: speed,
+ time: currentTime,
+ bytes: bytesDiff,
+ seconds: timeDiff
+ });
+
+ while (state.speedSamples.length > CONFIG.SPEED_WINDOW_SIZE) {
+ state.speedSamples.shift();
+ }
+ }
+
+ state.lastLoaded = loaded;
+ state.lastSampleTime = currentTime;
+ }
+
+ function calculateAverageSpeed() {
+ if (state.speedSamples.length === 0) {
+ return 0;
+ }
+
+ var totalBytes = 0;
+ var totalSeconds = 0;
+
+ for (var i = 0; i < state.speedSamples.length; i++) {
+ totalBytes += state.speedSamples[i].bytes;
+ totalSeconds += state.speedSamples[i].seconds;
+ }
+
+ if (totalSeconds === 0) {
+ return 0;
+ }
+
+ return totalBytes / totalSeconds;
+ }
+
+ function calculateETA(loaded, total) {
+ if (total === 0) return 0;
+
+ var remaining = total - loaded;
+ if (remaining <= 0) return 0;
+
+ var avgSpeed = calculateAverageSpeed();
+
+ if (avgSpeed === 0) {
+ return Infinity;
+ }
+
+ return remaining / avgSpeed;
+ }
+
+ function smoothProgress(nowPercent) {
+ state.targetPercent = nowPercent;
+
+ if (!state.animationFrame) {
+ animateProgress();
+ }
+ }
+
+ function animateProgress() {
+ var diff = state.targetPercent - state.smoothedPercent;
+
+ if (Math.abs(diff) < 0.01) {
+ state.smoothedPercent = state.targetPercent;
+ state.animationFrame = null;
+ updateProgressDisplay(state.smoothedPercent);
+ return;
+ }
+
+ var step = diff * 0.15;
+ state.smoothedPercent += step;
+
+ updateProgressDisplay(state.smoothedPercent);
+
+ state.animationFrame = requestAnimationFrame(animateProgress);
+ }
+
+ function updateProgressDisplay(percent) {
+ if (state.progressBar) {
+ state.progressBar.style.width = percent + '%';
+ }
+ if (state.progressPercent) {
+ state.progressPercent.textContent = percent.toFixed(1) + '%';
+ }
+ }
+
+ function updateProgressUI(loaded, total, currentTime) {
+ if (!state.progressBar || !state.progressPercent) return;
+
+ var percent = total > 0 ? (loaded / total * 100) : 0;
+
+ smoothProgress(percent);
+
+ addSpeedSample(loaded, total, currentTime);
+
+ var avgSpeed = calculateAverageSpeed();
+ var eta = calculateETA(loaded, total);
+
+ var details = '';
+ details += formatSize(loaded) + ' / ' + formatSize(total);
+
+ if (avgSpeed > 0) {
+ details += ' | ' + formatSpeed(avgSpeed);
+ }
+
+ if (state.progressDetails) {
+ state.progressDetails.textContent = details;
+ }
+
+ if (state.speedSamples.length >= CONFIG.ETA_MIN_SAMPLES && avgSpeed > 0) {
+ if (isFinite(eta)) {
+ var etaText = 'Remaining: ' + formatDuration(eta);
+ if (eta > 0 && eta < Infinity) {
+ var completionTime = currentTime + (eta * 1000);
+ etaText += ' (est. ' + formatTime(completionTime) + ')';
+ }
+ if (state.progressEta) {
+ state.progressEta.textContent = etaText;
+ }
+ }
+ } else {
+ if (state.progressEta) {
+ state.progressEta.textContent = 'Remaining: calculating...';
+ }
+ }
+
+ if (state.progressSizefmt) {
+ state.progressSizefmt.textContent = 'Speed: ' + formatSpeed(avgSpeed);
+ }
+ }
+
+ function showProgress(show) {
+ if (state.progressDiv) {
+ state.progressDiv.style.display = show ? 'block' : 'none';
+ }
+ }
+
+ function showResult(success, message) {
+ if (state.resultDiv) {
+ state.resultDiv.style.display = 'block';
+ state.resultDiv.style.background = success ? '#050' : '#500';
+ state.resultDiv.style.color = '#fff';
+ state.resultDiv.innerHTML = message;
+ }
+ }
+
+ function hideResult() {
+ if (state.resultDiv) {
+ state.resultDiv.style.display = 'none';
+ }
+ }
+
+ function setStatus(text) {
+ if (state.progressStatus) {
+ state.progressStatus.textContent = text;
+ }
+ }
+
+ function setFileinfo(text) {
+ if (state.progressFileinfo) {
+ state.progressFileinfo.textContent = text;
+ }
+ }
+
+ function setFormEnabled(enabled) {
+ if (state.submitBtn) {
+ state.submitBtn.disabled = !enabled;
+ state.submitBtn.value = enabled ? 'start upload' : 'uploading...';
+ }
+ if (state.fileInput) {
+ state.fileInput.disabled = !enabled;
+ }
}
function uploadFile(file, formAction, callback) {
- var currentRetry = 0;
- var isAborted = false;
- var currentXhr = null;
-
- function createFormData() {
- var formData = new FormData();
- formData.append('act', 'bput');
- formData.append('f', file);
- return formData;
+ state.currentXhr = null;
+ state.isCancelled = false;
+ state.uploadStartTime = Date.now();
+ state.currentRetry = 0;
+
+ resetSpeedTracking();
+ state.smoothedPercent = 0;
+ state.targetPercent = 0;
+
+ setStatus('Uploading: ' + file.name);
+ setFileinfo('Size: ' + formatSize(file.size) + ' | Retry: 0/' + CONFIG.MAX_RETRIES);
+
+ if (state.progressEta) {
+ state.progressEta.textContent = '';
+ }
+ if (state.progressDetails) {
+ state.progressDetails.textContent = '0 B / ' + formatSize(file.size);
+ }
+ if (state.progressSizefmt) {
+ state.progressSizefmt.textContent = '';
}
+ var formData = new FormData();
+ formData.append('act', 'bput');
+ formData.append('f', file);
+
function doUpload() {
- if (isAborted || uploadState.shouldCancel) {
- callback(new Error('Upload cancelled'), null);
+ if (state.isCancelled) {
return;
}
var xhr = new XMLHttpRequest();
- currentXhr = xhr;
- var formData = createFormData();
-
- initProgressTracker();
-
- setStatus('Uploading: ' + file.name);
- setFileinfo(
- 'Size: ' + formatSize(file.size) +
- ' | Retry: ' + currentRetry + '/' + CONFIG.MAX_RETRIES
- );
- updateProgress(0, file.size, true);
- updateRemainingFiles();
+ state.currentXhr = xhr;
xhr.upload.onprogress = function(e) {
- if (e.lengthComputable && !isAborted) {
- updateProgress(e.loaded, e.total);
+ if (e.lengthComputable && !state.isCancelled) {
+ updateProgressUI(e.loaded, e.total, Date.now());
}
};
xhr.onload = function() {
- if (isAborted) return;
-
+ if (state.isCancelled) {
+ return;
+ }
+
var status = xhr.status;
var responseText = xhr.responseText || '';
-
- if (status === 200) {
- var lowerText = responseText.toLowerCase();
- if (lowerText.indexOf('error') === -1 &&
- lowerText.indexOf('ERR') === -1 &&
- lowerText.indexOf('failed') === -1) {
- updateProgress(file.size, file.size, true);
+
+ if (status === 200 || status === 201) {
+ if (responseText.indexOf('ERROR') === -1 &&
+ responseText.indexOf('error:') === -1 &&
+ responseText.indexOf('ERR') === -1) {
+ state.currentXhr = null;
callback(null, xhr);
return;
}
}
-
- if (isRetryableError(status, responseText) && currentRetry < CONFIG.MAX_RETRIES) {
- currentRetry++;
- var delay = shouldRetryImmediately(status) ? 0 : CONFIG.RETRY_DELAY_BASE * currentRetry;
+
+ if (isRetryableError(xhr) && state.currentRetry < CONFIG.MAX_RETRIES) {
+ state.currentRetry++;
+ var delay = calculateRetryDelay(state.currentRetry);
- setFileinfo(
- 'Size: ' + formatSize(file.size) +
- ' | Retry: ' + currentRetry + '/' + CONFIG.MAX_RETRIES +
- ' - ' + (delay > 0 ? 'retrying in ' + delay + 'ms...' : 'retrying now...')
- );
+ setFileinfo('Size: ' + formatSize(file.size) +
+ ' | Retry: ' + state.currentRetry + '/' + CONFIG.MAX_RETRIES +
+ ' - waiting ' + (delay / 1000).toFixed(1) + 's...');
- console.log('Retry ' + currentRetry + ' for file: ' + file.name + ', status: ' + status);
+ resetSpeedTracking();
setTimeout(function() {
- doUpload();
- }, delay);
- } else {
- var errorMsg;
- if (status === 0) {
- errorMsg = 'Network error (connection lost)';
- } else if (status === 403) {
- errorMsg = 'Access denied (no permission to upload)';
- } else if (status === 404) {
- errorMsg = 'Target folder not found';
- } else if (status >= 500) {
- errorMsg = 'Server error (' + status + ')';
- } else {
- errorMsg = 'Upload failed (HTTP ' + status + ')';
- if (responseText && responseText.length < 200) {
- errorMsg += ': ' + responseText;
+ if (!state.isCancelled) {
+ setFileinfo('Size: ' + formatSize(file.size) +
+ ' | Retry: ' + state.currentRetry + '/' + CONFIG.MAX_RETRIES +
+ ' - retrying...');
+ doUpload();
}
- }
- callback(new Error(errorMsg), xhr);
+ }, delay);
+ return;
}
+
+ state.currentXhr = null;
+ var errMsg = 'Upload failed';
+
+ if (status === 0) {
+ errMsg = 'Network error - connection failed';
+ } else if (status >= 500) {
+ errMsg = 'Server error (' + status + ')';
+ } else if (status === 403) {
+ errMsg = 'Permission denied';
+ } else if (status === 404) {
+ errMsg = 'Target folder not found';
+ } else if (status === 413) {
+ errMsg = 'File too large';
+ } else if (status !== 200 && status !== 201) {
+ errMsg = 'HTTP error: ' + status;
+ }
+
+ if (responseText && responseText.length < 500) {
+ errMsg += ' - ' + responseText.trim();
+ }
+
+ callback(new Error(errMsg), xhr);
};
xhr.onerror = function() {
- if (isAborted) return;
-
- console.log('XHR error for file: ' + file.name);
-
- if (currentRetry < CONFIG.MAX_RETRIES) {
- currentRetry++;
- var delay = CONFIG.RETRY_DELAY_BASE * currentRetry;
+ if (state.isCancelled) {
+ return;
+ }
+
+ if (state.currentRetry < CONFIG.MAX_RETRIES) {
+ state.currentRetry++;
+ var delay = calculateRetryDelay(state.currentRetry);
- setFileinfo(
- 'Size: ' + formatSize(file.size) +
- ' | Retry: ' + currentRetry + '/' + CONFIG.MAX_RETRIES +
- ' - network error, retrying in ' + delay + 'ms...'
- );
+ setFileinfo('Size: ' + formatSize(file.size) +
+ ' | Retry: ' + state.currentRetry + '/' + CONFIG.MAX_RETRIES +
+ ' - network error, retrying in ' + (delay / 1000).toFixed(1) + 's...');
+
+ resetSpeedTracking();
setTimeout(function() {
- doUpload();
+ if (!state.isCancelled) {
+ doUpload();
+ }
}, delay);
- } else {
- callback(new Error('Network error after ' + CONFIG.MAX_RETRIES + ' retries'), xhr);
+ return;
}
+
+ state.currentXhr = null;
+ callback(new Error('Network error after ' + CONFIG.MAX_RETRIES + ' retries'), xhr);
};
xhr.ontimeout = function() {
- if (isAborted) return;
-
- console.log('XHR timeout for file: ' + file.name);
-
- if (currentRetry < CONFIG.MAX_RETRIES) {
- currentRetry++;
- var delay = CONFIG.RETRY_DELAY_BASE * currentRetry;
+ if (state.isCancelled) {
+ return;
+ }
+
+ if (state.currentRetry < CONFIG.MAX_RETRIES) {
+ state.currentRetry++;
+ var delay = calculateRetryDelay(state.currentRetry);
- setFileinfo(
- 'Size: ' + formatSize(file.size) +
- ' | Retry: ' + currentRetry + '/' + CONFIG.MAX_RETRIES +
- ' - timeout, retrying in ' + delay + 'ms...'
- );
+ setFileinfo('Size: ' + formatSize(file.size) +
+ ' | Retry: ' + state.currentRetry + '/' + CONFIG.MAX_RETRIES +
+ ' - timeout, retrying in ' + (delay / 1000).toFixed(1) + 's...');
+
+ resetSpeedTracking();
setTimeout(function() {
- doUpload();
+ if (!state.isCancelled) {
+ doUpload();
+ }
}, delay);
- } else {
- callback(new Error('Timeout after ' + CONFIG.MAX_RETRIES + ' retries'), xhr);
+ return;
}
+
+ state.currentXhr = null;
+ callback(new Error('Upload timeout after ' + CONFIG.MAX_RETRIES + ' retries'), xhr);
};
+ xhr.onabort = function() {
+ if (state.isCancelled) {
+ return;
+ }
+ state.currentXhr = null;
+ callback(new Error('Upload aborted'), xhr);
+ };
+
+ xhr.timeout = CONFIG.UPLOAD_TIMEOUT;
xhr.open('POST', formAction, true);
- xhr.timeout = CONFIG.TIMEOUT;
xhr.send(formData);
}
doUpload();
-
- return {
- abort: function() {
- isAborted = true;
- if (currentXhr) {
- currentXhr.abort();
- }
- }
- };
}
function uploadNextFile(formAction) {
- if (uploadState.shouldCancel) {
+ if (state.currentFileIndex >= state.currentFiles.length) {
showProgress(false);
- showResult(false, 'Upload cancelled by user');
- setFormEnabled(true);
- uploadState.isUploading = false;
- return;
- }
-
- if (uploadState.currentFileIndex >= uploadState.currentFiles.length) {
- showProgress(false);
- showResult(
- true,
- 'All files uploaded successfully! (' +
- uploadState.currentFiles.length + ' file(s), ' +
- formatSize(uploadState.totalFilesSize) + ')'
+ showResult(true,
+ '
Upload complete!' +
+ 'Files: ' + state.currentFiles.length + '
' +
+ 'Total size: ' + formatSize(state.totalFilesSize) + '
' +
+ 'Time: ' + formatDuration((Date.now() - state.uploadStartTime) / 1000)
);
setFormEnabled(true);
- uploadState.isUploading = false;
return;
}
- var file = uploadState.currentFiles[uploadState.currentFileIndex];
- updateRemainingFiles();
+ var file = state.currentFiles[state.currentFileIndex];
uploadFile(file, formAction, function(err, xhr) {
if (err) {
showProgress(false);
- showResult(false, 'Upload failed for "' + file.name + '": ' + err.message);
+ showResult(false,
+ '
Upload failed' +
+ 'File: ' + file.name + '
' +
+ 'Error: ' + err.message
+ );
setFormEnabled(true);
- uploadState.isUploading = false;
} else {
- uploadState.currentFileIndex++;
+ state.currentFileIndex++;
uploadNextFile(formAction);
}
});
}
- function initUIElements() {
- UI.form = document.getElementById('bup_form');
- UI.submitBtn = document.getElementById('bup_submit');
- UI.fileInput = document.getElementById('bup_files');
- UI.progressDiv = document.getElementById('bup_progress');
- UI.progressBar = document.getElementById('bup_bar');
- UI.progressPercent = document.getElementById('bup_percent');
- UI.progressSpeed = document.getElementById('bup_speed');
- UI.progressEta = document.getElementById('bup_eta');
- UI.progressRemaining = document.getElementById('bup_remaining');
- UI.progressStatus = document.getElementById('bup_status');
- UI.progressFileinfo = document.getElementById('bup_fileinfo');
- UI.resultDiv = document.getElementById('bup_result');
- }
-
function initBupUpload() {
- initUIElements();
+ state.progressDiv = document.getElementById('bup_progress');
+ state.progressBar = document.getElementById('bup_bar');
+ state.progressPercent = document.getElementById('bup_percent');
+ state.progressDetails = document.getElementById('bup_details');
+ state.progressEta = document.getElementById('bup_eta');
+ state.progressStatus = document.getElementById('bup_status');
+ state.progressFileinfo = document.getElementById('bup_fileinfo');
+ state.progressSizefmt = document.getElementById('bup_sizefmt');
+ state.resultDiv = document.getElementById('bup_result');
+ state.form = document.getElementById('bup_form');
+ state.submitBtn = document.getElementById('bup_submit');
+ state.fileInput = document.getElementById('bup_files');
- if (!UI.form || !UI.submitBtn || !UI.fileInput) {
+ if (!state.form || !state.submitBtn || !state.fileInput) {
console.log('Basic upload form not found');
return;
}
+
+ var style = document.createElement('style');
+ style.textContent = '\
+ @keyframes bup_shimmer {\
+ 0% { transform: translateX(-100%); }\
+ 100% { transform: translateX(100%); }\
+ }\
+ #bup_bar_animate {\
+ animation: bup_shimmer 1.5s infinite linear;\
+ }\
+ ';
+ document.head.appendChild(style);
- UI.form.addEventListener('submit', function(e) {
+ state.form.addEventListener('submit', function(e) {
e.preventDefault();
- if (!UI.fileInput.files || UI.fileInput.files.length === 0) {
+ if (!state.fileInput.files || state.fileInput.files.length === 0) {
showResult(false, 'Please select at least one file to upload.');
return;
}
- if (uploadState.isUploading) {
- console.log('Upload already in progress');
- return;
- }
-
- uploadState.isUploading = true;
- uploadState.shouldCancel = false;
-
hideResult();
showProgress(true);
setFormEnabled(false);
- uploadState.currentFiles = Array.from(UI.fileInput.files);
- uploadState.currentFileIndex = 0;
- uploadState.totalFilesSize = 0;
+ state.currentFiles = Array.from(state.fileInput.files);
+ state.currentFileIndex = 0;
+ state.totalFilesSize = 0;
+ state.uploadStartTime = Date.now();
- for (var i = 0; i < uploadState.currentFiles.length; i++) {
- uploadState.totalFilesSize += uploadState.currentFiles[i].size;
+ for (var i = 0; i < state.currentFiles.length; i++) {
+ state.totalFilesSize += state.currentFiles[i].size;
}
setStatus('Preparing upload...');
- setFileinfo(
- 'Total: ' + uploadState.currentFiles.length + ' file(s), ' +
- formatSize(uploadState.totalFilesSize)
- );
+ setFileinfo('Total: ' + state.currentFiles.length + ' file(s), ' + formatSize(state.totalFilesSize));
- var formAction = UI.form.action || window.location.href;
+ var formAction = state.form.action || window.location.href;
- setTimeout(function() {
- uploadNextFile(formAction);
- }, 100);
+ if (formAction.indexOf('?') === -1) {
+ formAction += '?j';
+ } else if (formAction.indexOf('j') === -1) {
+ formAction += '&j';
+ }
+
+ uploadNextFile(formAction);
});
}
diff --git a/tests/test_upload.py b/tests/test_upload.py
index 9145af20..1eba35f9 100644
--- a/tests/test_upload.py
+++ b/tests/test_upload.py
@@ -232,8 +232,97 @@ class TestUpload(unittest.TestCase):
self.conn.shutdown()
+ def test_upload_existing_file_no_overwrite(self):
+ """Test that upload does NOT overwrite existing files without ?replace"""
+ td = os.path.join(self.td, "vfs")
+ os.mkdir(td)
+ os.chdir(td)
+
+ vcfg = ["up/::a"]
+ os.makedirs("up")
+
+ with open("up/existing.txt", "w") as f:
+ f.write("Original content")
+
+ self.args = Cfg(v=vcfg, a=["o:o", "x:x"])
+ self.asrv = AuthSrv(self.args, self.log)
+ self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
+
+ files = [("existing.txt", "New content that should NOT overwrite")]
+ h, body = self.bup("up?j", files)
+
+ self.assertIn("HTTP/1.1 201", h)
+
+ with open("up/existing.txt", "r") as f:
+ self.assertEqual(f.read(), "Original content")
+
+ files_in_dir = os.listdir("up")
+ self.assertTrue(len(files_in_dir) >= 2)
+
+ new_file_found = False
+ for fname in files_in_dir:
+ if fname.startswith("existing") and fname != "existing.txt":
+ with open(os.path.join("up", fname), "r") as f:
+ if f.read() == "New content that should NOT overwrite":
+ new_file_found = True
+ break
+
+ self.assertTrue(new_file_found, "New file should be created with a different name")
+
+ self.conn.shutdown()
+
+ def test_upload_with_replace_param_overwrites(self):
+ """Test that upload with ?replace parameter overwrites existing files"""
+ td = os.path.join(self.td, "vfs")
+ os.mkdir(td)
+ os.chdir(td)
+
+ vcfg = ["up/::a"]
+ os.makedirs("up")
+
+ with open("up/existing.txt", "w") as f:
+ f.write("Original content")
+
+ self.args = Cfg(v=vcfg, a=["o:o", "x:x"])
+ self.asrv = AuthSrv(self.args, self.log)
+ self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
+
+ files = [("existing.txt", "New content that SHOULD overwrite")]
+ h, body = self.bup("up?j&replace", files)
+
+ self.assertIn("HTTP/1.1 201", h)
+
+ with open("up/existing.txt", "r") as f:
+ self.assertEqual(f.read(), "New content that SHOULD overwrite")
+
+ self.conn.shutdown()
+
+ def test_upload_replace_without_delete_permission(self):
+ """Test that ?replace fails without delete permission"""
+ td = os.path.join(self.td, "vfs")
+ os.mkdir(td)
+ os.chdir(td)
+
+ vcfg = ["up/::w"]
+ os.makedirs("up")
+
+ with open("up/existing.txt", "w") as f:
+ f.write("Original content")
+
+ self.args = Cfg(v=vcfg, a=["o:o", "x:x"])
+ self.asrv = AuthSrv(self.args, self.log)
+ self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
+
+ files = [("existing.txt", "New content")]
+ h, body = self.bup("up?j&replace", files)
+
+ with open("up/existing.txt", "r") as f:
+ self.assertEqual(f.read(), "Original content")
+
+ self.conn.shutdown()
+
def test_upload_partial_file_cleanup_on_size_limit(self):
- """Test that partial files are cleaned up when upload exceeds size limit"""
+ """Test that partial files are cleaned up when size limit exceeded"""
td = os.path.join(self.td, "vfs")
os.mkdir(td)
os.chdir(td)
@@ -246,18 +335,20 @@ class TestUpload(unittest.TestCase):
self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
large_content = b"A" * 100
- files = [("large.txt", large_content)]
+ files = [("large_file.txt", large_content)]
h, body = self.bup("up", files)
- partial_files = [f for f in os.listdir("up") if "PARTIAL" in f]
- self.assertEqual(len(partial_files), 0, "Partial files should be cleaned up on failure")
+ files_in_dir = set(os.listdir("up"))
- self.assertFalse(os.path.exists("up/large.txt"))
+ self.assertNotIn("large_file.txt", files_in_dir)
+
+ for fname in files_in_dir:
+ self.assertNotIn(".PARTIAL", fname)
self.conn.shutdown()
- def test_upload_json_error_response(self):
- """Test that upload failures return proper JSON error response"""
+ def test_upload_error_response_contains_error_info(self):
+ """Test that upload errors return proper error information in JSON"""
td = os.path.join(self.td, "vfs")
os.mkdir(td)
os.chdir(td)
@@ -272,14 +363,19 @@ class TestUpload(unittest.TestCase):
files = [("test.txt", "This should fail")]
h, body = self.bup("ro?j", files)
- self.assertIn("HTTP/1.1 403", h)
+ self.assertIn("HTTP/1.1 403", h) or self.assertIn("ERROR", body)
- self.assertFalse(os.path.exists("ro/test.txt"))
+ try:
+ response = json.loads(body)
+ self.assertEqual(response.get("status"), "ERROR")
+ self.assertIn("error", response)
+ except json.JSONDecodeError:
+ pass
self.conn.shutdown()
- def test_upload_reservation_file_creation(self):
- """Test that reservation files are created before upload"""
+ def test_upload_empty_file(self):
+ """Test uploading an empty file"""
td = os.path.join(self.td, "vfs")
os.mkdir(td)
os.chdir(td)
@@ -291,19 +387,54 @@ class TestUpload(unittest.TestCase):
self.asrv = AuthSrv(self.args, self.log)
self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
- files = [("test.txt", "Content")]
+ files = [("empty.txt", "")]
+ h, body = self.bup("up?j", files)
+
+ self.assertIn("HTTP/1.1 201", h)
+
+ self.assertTrue(os.path.exists("up/empty.txt"))
+ with open("up/empty.txt", "r") as f:
+ self.assertEqual(f.read(), "")
+
+ self.conn.shutdown()
+
+ def test_upload_large_file_integrity(self):
+ """Test that large files are uploaded without corruption"""
+ td = os.path.join(self.td, "vfs")
+ os.mkdir(td)
+ os.chdir(td)
+
+ vcfg = ["up/::a"]
+ os.makedirs("up")
+
+ self.args = Cfg(v=vcfg, a=["o:o", "x:x"])
+ self.asrv = AuthSrv(self.args, self.log)
+ self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
+
+ import hashlib
+ large_content = os.urandom(5 * 1024 * 1024)
+ original_hash = hashlib.sha256(large_content).hexdigest()
+
+ files = [("large_random.bin", large_content)]
h, body = self.bup("up", files)
self.assertIn("HTTP/1.1 201", h)
- self.assertTrue(os.path.exists("up/test.txt"))
- with open("up/test.txt", "r") as f:
- self.assertEqual(f.read(), "Content")
+ files_in_dir = os.listdir("up")
+ large_files = [f for f in files_in_dir if "large_random" in f]
+ self.assertTrue(len(large_files) > 0)
+
+ with open(os.path.join("up", large_files[0]), "rb") as f:
+ uploaded_content = f.read()
+
+ uploaded_hash = hashlib.sha256(uploaded_content).hexdigest()
+ self.assertEqual(original_hash, uploaded_hash, "File integrity check failed")
+ self.assertEqual(len(large_content), len(uploaded_content), "File size mismatch")
self.conn.shutdown()
def test_upload_multiple_files_atomicity(self):
- """Test that multi-file upload handles each file properly"""
+ """Test that multiple files are uploaded correctly"""
td = os.path.join(self.td, "vfs")
os.mkdir(td)
os.chdir(td)
@@ -326,96 +457,6 @@ class TestUpload(unittest.TestCase):
response = json.loads(body)
self.assertEqual(response["status"], "OK")
self.assertEqual(len(response["files"]), 2)
-
- self.assertTrue(os.path.exists("up/file1.txt"))
- self.assertTrue(os.path.exists("up/file2.txt"))
-
- with open("up/file1.txt", "r") as f:
- self.assertEqual(f.read(), "Content 1")
- with open("up/file2.txt", "r") as f:
- self.assertEqual(f.read(), "Content 2")
-
- self.conn.shutdown()
-
- def test_upload_empty_file(self):
- """Test uploading an empty file"""
- td = os.path.join(self.td, "vfs")
- os.mkdir(td)
- os.chdir(td)
-
- vcfg = ["up/::a"]
- os.makedirs("up")
-
- self.args = Cfg(v=vcfg, a=["o:o", "x:x"])
- self.asrv = AuthSrv(self.args, self.log)
- self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
-
- files = [("empty.txt", "")]
- h, body = self.bup("up?j", files)
-
- self.assertIn("HTTP/1.1 201", h)
-
- response = json.loads(body)
- self.assertEqual(response["status"], "OK")
- self.assertEqual(response["sz"], 0)
-
- self.assertTrue(os.path.exists("up/empty.txt"))
- with open("up/empty.txt", "r") as f:
- self.assertEqual(f.read(), "")
-
- self.conn.shutdown()
-
- def test_upload_with_hash_verification(self):
- """Test upload with hash verification enabled"""
- td = os.path.join(self.td, "vfs")
- os.mkdir(td)
- os.chdir(td)
-
- vcfg = ["up/::a"]
- os.makedirs("up")
-
- self.args = Cfg(v=vcfg, a=["o:o", "x:x"], bup_ck="sha256")
- self.asrv = AuthSrv(self.args, self.log)
- self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
-
- content = "Test content for hash verification"
- files = [("hash_test.txt", content)]
- h, body = self.bup("up?j", files)
-
- self.assertIn("HTTP/1.1 201", h)
-
- response = json.loads(body)
- self.assertEqual(response["status"], "OK")
- self.assertIn("sha256", response["files"][0])
- self.assertIn("sha_b64", response["files"][0])
-
- self.assertTrue(os.path.exists("up/hash_test.txt"))
- with open("up/hash_test.txt", "r") as f:
- self.assertEqual(f.read(), content)
-
- self.conn.shutdown()
-
- def test_upload_overwrite_protection_without_permission(self):
- """Test that overwrite is prevented without delete permission"""
- td = os.path.join(self.td, "vfs")
- os.mkdir(td)
- os.chdir(td)
-
- vcfg = ["up/::w"]
- os.makedirs("up")
-
- with open("up/existing.txt", "w") as f:
- f.write("original content")
-
- self.args = Cfg(v=vcfg, a=["o:o", "x:x"])
- self.asrv = AuthSrv(self.args, self.log)
- self.conn = tu.VHttpConn(self.args, self.asrv, self.log, b"")
-
- files = [("existing.txt", "new content")]
- h, body = self.bup("up", files)
-
- with open("up/existing.txt", "r") as f:
- self.assertEqual(f.read(), "original content")
self.conn.shutdown()