WSL File Transfer Guide: Methods, Scripts and Best Practices

# Required tools (install if missing):
sudo apt update
sudo apt install -y rsync
sudo apt install -y openssh-client
sudo apt install -y tar
sudo apt install -y gzip

# Open parent directory
explorer.exe “..”

# Open home directory
explorer.exe ~

# Copy with progress indicator (using pv)
sudo apt-get install pv
pv /mnt/c/source/largefile.dat > ~/destination/largefile.dat

# Copy multiple files
cp -v /mnt/c/source/{file1.txt,file2.txt,file3.txt} ~/destination/

# Copy all files of specific type
cp -v /mnt/c/source/*.{jpg,png,gif} ~/destination/

# Copy with backup
cp -b /mnt/c/source/file.txt ~/destination/

# Copy only newer files
cp -u /mnt/c/source/* ~/destination/

# Move directory
mv -v /mnt/c/source/directory/ ~/destination/

# Move with backup
mv -b /mnt/c/source/file.txt ~/destination/

# Move only newer files
mv -u /mnt/c/source/* ~/destination/

# Dry run to check what will be copied
rsync -avn /mnt/c/source/ ~/destination/

# Sync with deletion (mirror)
rsync -av –delete /mnt/c/source/ ~/destination/

# Exclude specific patterns
rsync -av –exclude=’*.tmp’ –exclude=’cache/’ /mnt/c/source/ ~/destination/

# Resume partial transfers
rsync -avP –partial –progress /mnt/c/source/ ~/destination/

# Limit bandwidth usage (1000 KB/s)
rsync -av –bwlimit=1000 /mnt/c/source/ ~/destination/

# Ignore patterns
ignore = Name *.tmp
ignore = Name *.temp
ignore = Path */node_modules

# Preferences
batch = true
confirmbigdel = true
EOL

# Run synchronization
unison mysync

# Sync with progress
rclone sync -P /mnt/c/source remote:destination

# Dry run
rclone sync –dry-run /mnt/c/source remote:destination

# Sync with size-only comparison
rsync -av –size-only /mnt/c/source/ ~/destination/

# Sync with checksum verification
rsync -avc /mnt/c/source/ ~/destination/

# Sync and delete extra files (mirror)
rsync -av –delete-after /mnt/c/source/ ~/destination/

# Sync with backup of changed files
rsync -av –backup –backup-dir=/path/to/backups –suffix=.bak /mnt/c/source/ ~/destination/

# Create archive with progress bar
tar -czf – ~/source/ | pv > /mnt/c/backup.tar.gz

# Combine split archives
cat /mnt/c/backup.tar.gz.part* | tar -xzf – -C ~/destination/

# Copy with compression
scp -C /mnt/c/source/file.txt user@remote:/destination/

# Create split zip archives
zip -r -s 1g /mnt/c/split.zip ~/source/

# Split into volumes
7z a -v1g /mnt/c/split.7z ~/source/

#!/bin/bash

# Batch processing script
source_dir=”/mnt/c/source”
dest_dir=”~/destination”
max_processes=4

# Create destination if it doesn’t exist
mkdir -p “$dest_dir”

# Process files in batches
find “$source_dir” -type f | while read -r file; do
# Count current processes
while [ $(jobs -p | wc -l) -ge $max_processes ]; do
sleep 1
done

# Copy file in background
cp “$file” “$dest_dir” &
done

# Wait for all processes to complete
wait

#!/bin/bash

# Complete backup script with logging and error handling
# Save as: ~/scripts/backup.sh

# Configuration
SOURCE_DIR=”/home/username/projects”
BACKUP_DIR=”/mnt/c/backups”
LOG_DIR=”/home/username/logs”
TIMESTAMP=$(date +”%Y%m%d_%H%M%S”)
BACKUP_FILE=”backup_${TIMESTAMP}.tar.gz”
LOG_FILE=”${LOG_DIR}/backup_${TIMESTAMP}.log”
ERROR_LOG=”${LOG_DIR}/backup_errors_${TIMESTAMP}.log”
MAX_BACKUPS=5

# Create necessary directories
mkdir -p “$BACKUP_DIR” “$LOG_DIR”

# Logging function
log_message() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” | tee -a “$LOG_FILE”
}

# Error handling function
handle_error() {
local error_message=”$1″
echo “[ERROR] $(date ‘+%Y-%m-%d %H:%M:%S’) – $error_message” >> “$ERROR_LOG”
log_message “ERROR: $error_message”
exit 1
}

# Check disk space
check_disk_space() {
local required_space=$1
local available_space=$(df -k “$BACKUP_DIR” | awk ‘NR==2 {print $4}’)
if [ $available_space -lt $required_space ]; then
handle_error “Insufficient disk space. Required: ${required_space}KB, Available: ${available_space}KB”
fi
}

# Start backup process
log_message “Starting backup process…”

# Calculate required space (source directory size + 10% buffer)
SOURCE_SIZE=$(du -sk “$SOURCE_DIR” | cut -f1)
REQUIRED_SPACE=$((SOURCE_SIZE + (SOURCE_SIZE / 10)))
check_disk_space $REQUIRED_SPACE

# Create backup with progress
log_message “Creating backup archive…”
tar -czf “$BACKUP_DIR/$BACKUP_FILE” -C “$(dirname “$SOURCE_DIR”)” “$(basename “$SOURCE_DIR”)” 2>> “$ERROR_LOG” || \
handle_error “Failed to create backup archive”

# Verify backup integrity
log_message “Verifying backup integrity…”
tar -tzf “$BACKUP_DIR/$BACKUP_FILE” > /dev/null 2>> “$ERROR_LOG” || \
handle_error “Backup verification failed”

# Cleanup old backups
log_message “Cleaning up old backups…”
ls -t “$BACKUP_DIR”/backup_*.tar.gz | tail -n +$((MAX_BACKUPS + 1)) | xargs -r rm

# Calculate and log backup size
BACKUP_SIZE=$(du -h “$BACKUP_DIR/$BACKUP_FILE” | cut -f1)
log_message “Backup completed successfully. Size: $BACKUP_SIZE”

# Send notification (customize as needed)
if command -v notify-send &> /dev/null; then
notify-send “Backup Completed” “Backup size: $BACKUP_SIZE”
fi

#!/bin/bash

# Two-way sync script with conflict resolution
# Save as: ~/scripts/sync.sh

# Configuration
WSL_DIR=”/home/username/workspace”
WINDOWS_DIR=”/mnt/c/Users/Username/Projects”
CONFLICT_DIR=”/home/username/sync_conflicts”
LOG_FILE=”/home/username/logs/sync.log”

# Create necessary directories
mkdir -p “$CONFLICT_DIR”
mkdir -p “$(dirname “$LOG_FILE”)”

# Logging function
log() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” >> “$LOG_FILE”
}

# Conflict resolution function
handle_conflict() {
local file=”$1″
local timestamp=$(date +”%Y%m%d_%H%M%S”)
local conflict_file=”$CONFLICT_DIR/$(basename “$file”)_$timestamp”
cp “$file” “$conflict_file”
log “Conflict detected: $file -> $conflict_file”
}

# Sync function with conflict detection
sync_directories() {
local source=”$1″
local target=”$2″

# Use rsync for synchronization
rsync -avz –backup –backup-dir=”$CONFLICT_DIR” \
–suffix=”_$(date +%Y%m%d_%H%M%S)” \
–exclude=’.git/’ \
–exclude=’node_modules/’ \
–exclude=’*.tmp’ \
“$source/” “$target/” 2>> “$LOG_FILE”

if [ $? -eq 0 ]; then
log “Sync completed: $source -> $target”
else
log “Sync failed: $source -> $target”
fi
}

#!/bin/bash

# File transfer monitoring script
# Save as: ~/scripts/monitor.sh

# Configuration
WATCH_DIR=”/mnt/c/watched_directory”
LOG_FILE=”/home/username/logs/monitor.log”
PROCESSED_DIR=”/home/username/processed”
ERROR_DIR=”/home/username/errors”

# Create directories
mkdir -p “$PROCESSED_DIR” “$ERROR_DIR”

# Monitor function using inotifywait
monitor_directory() {
# Install inotify-tools if not present
if ! command -v inotifywait &> /dev/null; then
sudo apt-get install -y inotify-tools
}

while true; do
inotifywait -m -e create -e modify -e move “$WATCH_DIR” |
while read -r directory event filename; do
timestamp=$(date ‘+%Y-%m-%d %H:%M:%S’)
echo “[$timestamp] Event: $event File: $filename” >> “$LOG_FILE”

# Process the file
if [[ -f “$WATCH_DIR/$filename” ]]; then
case “${filename##*.}” in
txt|doc|pdf)
mv “$WATCH_DIR/$filename” “$PROCESSED_DIR/”
;;
*)
mv “$WATCH_DIR/$filename” “$ERROR_DIR/”
;;
esac
fi
done
done
}

# Run sync every 4 hours
0 */4 * * * ~/scripts/sync.sh

# Run monitoring script at system startup
@reboot ~/scripts/monitor.sh

# Check cron logs
grep CRON /var/log/syslog

#!/bin/bash

# Email notification function
# Save as: ~/scripts/notify.sh

send_email() {
local subject=”$1″
local body=”$2″
local email=”your@email.com”

# Install mailutils if not present
if ! command -v mail &> /dev/null; then
sudo apt-get install -y mailutils
}

echo “$body” | mail -s “$subject” “$email”
}

# Example usage in backup script:
if [ $? -eq 0 ]; then
send_email “Backup Success” “Backup completed successfully. Size: $BACKUP_SIZE”
else
send_email “Backup Failed” “Backup process failed. Check error logs.”
fi

#!/bin/bash

# Resource monitoring script
# Save as: ~/scripts/monitor_resources.sh

monitor_resources() {
local pid=$1
local log_file=”$2″

while ps -p $pid > /dev/null; do
{
echo “===== $(date ‘+%Y-%m-%d %H:%M:%S’) =====”
echo “CPU Usage:”
ps -p $pid -o %cpu,%mem,cmd
echo “Memory Usage:”
free -h
echo “Disk I/O:”
iostat -x 1 1
echo “Network Usage:”
nethogs -t
} >> “$log_file”
sleep 5
done
}

# Handle Windows ACL issues
# From Windows PowerShell (Admin):
icacls “C:\path\to\directory” /grant “Users”:(OI)(CI)F /T

# WSL permissions fix script
#!/bin/bash
fix_permissions() {
local target_dir=”$1″
find “$target_dir” -type d -exec chmod 755 {} \;
find “$target_dir” -type f -exec chmod 644 {} \;
chown -R $USER:$USER “$target_dir”
}

case “$direction” in
‘win2wsl’)
wslpath -u “$path”
;;
‘wsl2win’)
wslpath -w “$path”
;;
*)
echo “Invalid direction. Use ‘win2wsl’ or ‘wsl2win'”
return 1
;;
esac
}

# Performance monitoring script
#!/bin/bash
monitor_transfer_performance() {
local source=”$1″
local dest=”$2″
local start_time=$(date +%s)

# Transfer with progress
rsync -av –progress “$source” “$dest” | while read line; do
echo “$line”
current_time=$(date +%s)
elapsed=$((current_time – start_time))

# Log performance metrics
if [[ $line =~ ^[0-9]+% ]]; then
speed=$(echo “$line” | grep -oP ‘\d+\.\d+\w+/s’)
echo “Transfer Speed: $speed, Elapsed Time: ${elapsed}s”
fi
done
}

# Install necessary tools
sudo apt-get install -y testdisk photorec

# Create recovery directory
mkdir -p “$backup_dir”

# Run file recovery
sudo photorec /d=”$backup_dir” /cmd “$source_dir” quit
}

#!/bin/bash

# Error handling toolkit
# Save as: ~/scripts/error_handler.sh

# Error codes
declare -A ERROR_CODES=(
[1]=”Permission denied”
[2]=”Path not found”
[3]=”Disk full”
[4]=”Network error”
[5]=”Invalid argument”
)

# Error handling function
handle_error() {
local error_code=$1
local error_message=”${ERROR_CODES[$error_code]}”
local timestamp=$(date ‘+%Y-%m-%d %H:%M:%S’)
local log_file=”/home/username/logs/error.log”

# Log error
echo “[$timestamp] Error $error_code: $error_message” >> “$log_file”

# Take action based on error
case $error_code in
1) # Permission denied
fix_permissions
;;
2) # Path not found
create_missing_paths
;;
3) # Disk full
cleanup_old_files
;;
4) # Network error
retry_network_operation
;;
*)
echo “Unknown error code: $error_code”
;;
esac

return $error_code
}

# Helper functions
fix_permissions() {
sudo chown -R $USER:$USER “$target_path”
sudo chmod -R u+rw “$target_path”
}

create_missing_paths() {
mkdir -p “$target_path”
}

cleanup_old_files() {
find “$target_path” -type f -mtime +30 -delete
}

retry_network_operation() {
local max_retries=3
local retry_count=0

while [ $retry_count -lt $max_retries ]; do
if execute_network_operation; then
return 0
fi
retry_count=$((retry_count + 1))
sleep 5
done
return 1
}

#!/bin/bash

# Automated troubleshooter
# Save as: ~/scripts/troubleshoot.sh

troubleshoot_transfer() {
local source=”$1″
local dest=”$2″
local log_file=”/home/username/logs/troubleshoot.log”

# Check source existence
if [ ! -e “$source” ]; then
log_error “Source not found: $source”
return 1
fi

# Check destination permissions
if [ ! -w “$(dirname “$dest”)” ]; then
log_error “Cannot write to destination: $dest”
fix_permissions “$(dirname “$dest”)”
fi

# Check disk space
check_disk_space “$dest”

# Verify network connectivity
check_network_connectivity

# Monitor system resources
monitor_resources &
local monitor_pid=$!

# Attempt transfer
rsync -av –progress “$source” “$dest”
local transfer_status=$?

# Stop monitoring
kill $monitor_pid

return $transfer_status
}

#!/bin/bash

# Network diagnostics script
# Save as: ~/scripts/network_diagnostics.sh

check_network() {
local log_file=”/home/username/logs/network.log”

# Check WSL network interface
ip addr show >> “$log_file”

# Test DNS resolution
nslookup google.com >> “$log_file”

# Check Windows networking
/mnt/c/Windows/System32/ipconfig.exe /all >> “$log_file”

# Test connectivity
ping -c 4 8.8.8.8 >> “$log_file”

# Check ports
netstat -tuln >> “$log_file”
}

# Network repair function
repair_network() {
# Restart WSL networking
sudo service networking restart

# Flush DNS cache
sudo service networking restart

# Reset Windows DNS (requires admin)
powershell.exe -Command “ipconfig /flushdns”
}

#!/bin/bash

# Create optimized workspace
setup_workspace() {
# WSL-specific directories (faster Linux operations)
mkdir -p ~/workspace/{dev,build,temp}

# Windows-mounted directories (better Windows integration)
mkdir -p /mnt/c/workspace/{shared,output,backup}

# Create symbolic links for convenience
ln -s /mnt/c/workspace/shared ~/workspace/shared

# Add to .bashrc for persistent configuration
echo ‘
# Workspace configuration
export DEV_HOME=~/workspace
export WIN_SHARE=/mnt/c/workspace/shared
‘ >> ~/.bashrc

source ~/.bashrc
}

echo “Checking CPU usage…”
top -bn1 | head -n 20

echo “Checking memory…”
free -h

# Optimization recommendations
cat << EOL
Recommendations:
1. Use native WSL filesystem for Linux operations
2. Use Windows filesystem for Windows operations
3. Consider using compression for network transfers
4. Use appropriate tools based on file size
EOL
}

#!/bin/bash

optimize_memory() {
# Clear page cache
sudo sh -c “sync; echo 3 > /proc/sys/vm/drop_caches”

# Optimize swappiness
sudo sysctl vm.swappiness=10

# Set memory limits for WSL
# Add to /etc/wsl.conf:
echo ‘[wsl2]
memory=8GB
swap=2GB’ | sudo tee -a /etc/wsl.conf
}

# Monitor memory usage during transfers
monitor_memory() {
local pid=$1
while ps -p $pid > /dev/null; do
free -h
sleep 5
done
}

#!/bin/bash

secure_permissions() {
local target=”$1″

# Set secure base permissions
find “$target” -type d -exec chmod 750 {} \;
find “$target” -type f -exec chmod 640 {} \;

# Special handling for executables
find “$target” -type f -name “*.sh” -exec chmod 750 {} \;

# Set secure ownership
chown -R $USER:$USER “$target”

# Handle sensitive files
find “$target” -type f -name “*.key” -o -name “*.pem” -exec chmod 600 {} \;
}

# Security audit function
audit_permissions() {
local target=”$1″
local audit_log=”/home/username/logs/security_audit.log”

echo “Security Audit – $(date)” > “$audit_log”

# Check world-writable files
find “$target” -type f -perm -002 >> “$audit_log”

# Check setuid files
find “$target” -type f -perm -4000 >> “$audit_log”

# Check group writable files
find “$target” -type f -perm -020 >> “$audit_log”
}

# Encrypt file
openssl enc -aes-256-cbc -salt -in “$source” -out “$output” -k “$password”

# Save password securely
echo “$password” | gpg -e -r “user@email.com” > “${output}.key”

echo “File encrypted: $output”
echo “Key saved: ${output}.key”
}

# Directory encryption function
encrypt_directory() {
local source=”$1″
local output=”${source}.tar.gz.enc”

# Create archive
tar -czf – “$source” | \
openssl enc -aes-256-cbc -salt -out “$output”
}

#!/bin/bash

optimize_resources() {
# Set CPU priority
renice -n 10 -p $$

# Set I/O priority
ionice -c 2 -n 7 -p $$

# Limit memory usage
ulimit -v 8388608 # Limit virtual memory to 8GB

# Configure process niceness for background operations
export RSYNC_NICE=10
export RSYNC_IONICE=”ionice -c 2 -n 7″
}

# I/O monitoring function
monitor_io() {
local duration=$1
local interval=${2:-5}

for ((i=0; i<duration; i+=$interval)); do
iostat -x 1 1
sleep $interval
done
}

#!/bin/bash

optimize_network() {
# Set TCP optimization parameters
sudo sysctl -w \
net.ipv4.tcp_window_scaling=1 \
net.ipv4.tcp_timestamps=1 \
net.ipv4.tcp_sack=1 \
net.core.rmem_max=16777216 \
net.core.wmem_max=16777216

# Configure network buffer sizes
sudo sysctl -w \
net.ipv4.tcp_rmem=”4096 87380 16777216″ \
net.ipv4.tcp_wmem=”4096 65536 16777216″

# Enable BBR congestion control
sudo modprobe tcp_bbr
sudo sysctl -w net.ipv4.tcp_congestion_control=bbr
}

# Network monitoring function
monitor_network() {
local interface=”eth0″

while true; do
echo “Network Statistics – $(date)”
ifconfig $interface | grep “RX bytes”
sleep 5
done
}

#!/bin/bash

# Workflow automation script
configure_workflow() {
# Create workflow directories
mkdir -p ~/workflow/{input,processing,output,logs}

# Set up file watchers
inotifywait -m -r ~/workflow/input -e create -e modify |
while read path action file; do
process_file “$path$file”
done
}

# File processing function
process_file() {
local file=”$1″
local filename=$(basename “$file”)
local ext=”${filename##*.}”

case “$ext” in
txt|doc|pdf)
optimize_document “$file”
;;
jpg|png|gif)
optimize_image “$file”
;;
*)
echo “Unknown file type: $ext”
;;
esac
}

#!/bin/bash

# Development environment setup script
setup_dev_environment() {
# Base directories
declare -A DIRS=(
[“projects”]=”/home/username/dev/projects”
[“backup”]=”/mnt/c/dev_backup”
[“shared”]=”/mnt/c/shared_workspace”
[“temp”]=”/home/username/dev/temp”
[“logs”]=”/home/username/dev/logs”
)

# Create directory structure
for dir in “${!DIRS[@]}”; do
mkdir -p “${DIRS[$dir]}”
done

# Configure Git for cross-platform
git config –global core.autocrlf input
git config –global core.eol lf

# Create .gitignore
cat > ~/.gitignore_global << EOL *.log *.tmp .DS_Store node_modules/ **/bin/ **/obj/ .vs/ .vscode/ EOL git config –global core.excludesfile ~/.gitignore_global # Set up VSCode integration setup_vscode_integration # Configure environment variables setup_env_variables } # VSCode integration setup setup_vscode_integration() { cat > ~/.vscode/settings.json << EOL { “files.eol”: “\n”, “terminal.integrated.defaultProfile.windows”: “WSL”, “remote.WSL.fileWatcher.polling”: true, “files.watcherExclude”: { “**/node_modules/**”: true, “**/dist/**”: true, “**/build/**”: true } } EOL } # Environment variables setup setup_env_variables() { cat >> ~/.bashrc << EOL
# Development environment variables
export DEV_HOME=/home/username/dev
export WIN_SHARE=/mnt/c/shared_workspace
export PROJECT_ROOT=\$DEV_HOME/projects
export PATH=\$PATH:\$DEV_HOME/bin

# Aliases for common operations
alias cdp=’cd \$PROJECT_ROOT’
alias cdw=’cd \$WIN_SHARE’
alias dev=’cd \$DEV_HOME’
EOL
}

#!/bin/bash

# Project synchronization script
setup_project_sync() {
local project_name=”$1″
local wsl_path=”/home/username/dev/projects/$project_name”
local win_path=”/mnt/c/Projects/$project_name”

# Create project structure
mkdir -p “$wsl_path”/{src,tests,docs,scripts,build}

# Configure sync script
cat > “$wsl_path/scripts/sync.sh” << ‘EOL’
#!/bin/bash

# Two-way sync with conflict resolution
rsync -avz –delete \
–exclude={‘.git/’,’.env’,’node_modules/’} \
–backup –backup-dir=/home/username/dev/backup \
“$wsl_path/” “$win_path/”

rsync -avz –delete \
–exclude={‘.git/’,’.env’,’node_modules/’} \
–backup –backup-dir=/home/username/dev/backup \
“$win_path/” “$wsl_path/”
EOL

chmod +x “$wsl_path/scripts/sync.sh”
}

#!/bin/bash

# Database operations script
db_operations() {
# Configuration
local DB_NAME=”$1″
local DB_USER=”$2″
local BACKUP_DIR=”/mnt/c/db_backups”
local TIMESTAMP=$(date +”%Y%m%d_%H%M%S”)

# MySQL backup function
mysql_backup() {
mysqldump -u “$DB_USER” -p “$DB_NAME” | \
gzip > “$BACKUP_DIR/${DB_NAME}_${TIMESTAMP}.sql.gz”
}

# PostgreSQL backup function
postgres_backup() {
PGPASSWORD=”$DB_PASS” pg_dump -U “$DB_USER” “$DB_NAME” | \
gzip > “$BACKUP_DIR/${DB_NAME}_${TIMESTAMP}.sql.gz”
}

# MongoDB backup function
mongo_backup() {
mongodump –db “$DB_NAME” –out “$BACKUP_DIR/mongo_${TIMESTAMP}”
tar -czf “$BACKUP_DIR/${DB_NAME}_${TIMESTAMP}.tar.gz” \
“$BACKUP_DIR/mongo_${TIMESTAMP}”
rm -rf “$BACKUP_DIR/mongo_${TIMESTAMP}”
}
}

# Database restore function
db_restore() {
local backup_file=”$1″
local db_type=”$2″

case “$db_type” in
mysql)
gunzip < “$backup_file” | mysql -u “$DB_USER” -p “$DB_NAME”
;;
postgres)
gunzip < “$backup_file” | psql -U “$DB_USER” “$DB_NAME”
;;
mongodb)
tar -xzf “$backup_file”
mongorestore –db “$DB_NAME” “${backup_file%.*}”
;;
esac
}

#!/bin/bash

# Large file transfer script
transfer_large_file() {
local source=”$1″
local destination=”$2″
local chunk_size=”500M”

# Split file into chunks
split -b “$chunk_size” “$source” “${source}.part_”

# Transfer chunks with progress
for chunk in “${source}.part_”*; do
rsync -avP –partial “$chunk” “$destination/”

# Verify chunk integrity
if ! verify_checksum “$chunk” “$destination/$(basename “$chunk”)”; then
echo “Transfer failed for chunk: $chunk”
return 1
fi
done

# Reassemble file at destination
cat “$destination/${source}.part_”* > “$destination/$(basename “$source”)”
rm “$destination/${source}.part_”*

# Verify final file
verify_checksum “$source” “$destination/$(basename “$source”)”
}

# Checksum verification
verify_checksum() {
local source=”$1″
local dest=”$2″

local src_sum=$(sha256sum “$source” | cut -d’ ‘ -f1)
local dst_sum=$(sha256sum “$dest” | cut -d’ ‘ -f1)

[ “$src_sum” = “$dst_sum” ]
}

#!/bin/bash

# Parallel transfer script for large files
parallel_transfer() {
local source_dir=”$1″
local dest_dir=”$2″
local max_jobs=4

# Find all large files (>1GB)
find “$source_dir” -type f -size +1G | \
parallel -j “$max_jobs” \
“rsync -avz –progress {} $dest_dir/”

# Handle smaller files in bulk
find “$source_dir” -type f -size -1G | \
xargs -P “$max_jobs” -I {} \
cp {} “$dest_dir/”
}

# Monitor transfer progress
monitor_parallel_transfer() {
local dest_dir=”$1″
local log_file=”transfer_progress.log”

while true; do
echo “=== Transfer Progress $(date) ===” >> “$log_file”
du -sh “$dest_dir” >> “$log_file”
ps aux | grep “rsync\|cp” >> “$log_file”
sleep 10
done
}

#!/bin/bash

# Git integration script
setup_git_integration() {
# Configure Git for cross-platform
git config –global core.autocrlf input
git config –global core.eol lf

# Create .gitattributes
cat > .gitattributes << EOL # Auto detect text files and perform LF normalization * text=auto # Source code *.sh text eol=lf *.py text diff=python *.java text diff=java *.php text diff=php *.css text diff=css *.js text *.htm text diff=html *.html text diff=html *.xml text *.txt text *.ini text *.inc text *.pl text *.rb text diff=ruby *.properties text *.sql text # Documentation *.md text diff=markdown *.doc binary *.docx binary *.pdf binary *.rtf binary # Graphics *.png binary *.jpg binary *.gif binary *.ico binary *.svg text EOL # Setup hooks for automated tasks setup_git_hooks } # Git hooks setup setup_git_hooks() { # Pre-commit hook for Windows/Linux line ending checks cat > .git/hooks/pre-commit << ‘EOL’ #!/bin/bash if git rev-parse –verify HEAD >/dev/null 2>&1; then
against=HEAD
else
against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
fi

# Check for files with CRLF line endings
if git diff-index –cached –check $against; then
echo “Files have correct line endings.”
else
echo “Error: Found CRLF line endings. Please fix using dos2unix.”
exit 1
fi
EOL
chmod +x .git/hooks/pre-commit
}

# For executables
find “$target” -type f -name “*.sh” -exec chmod 755 {} \;

# Set ownership
chown -R $USER:$USER “$target”
}

echo “Checking CPU usage…”
top -bn1 | head -n 20

echo “Checking memory…”
free -h

# Optimization recommendations
cat << EOL
Recommendations:
1. Use native WSL filesystem for Linux operations
2. Use Windows filesystem for Windows operations
3. Consider using compression for network transfers
4. Use appropriate tools based on file size
EOL
}

# Backup corrupted file
mv “$dest” “${dest}.corrupted”

# Retry transfer with verification
rsync -avz –checksum “$source” “$dest”

# Verify again
sha256sum “$dest” > dest.sha256
if cmp -s source.sha256 dest.sha256; then
echo “Recovery successful”
rm “${dest}.corrupted”
else
echo “Recovery failed. Manual intervention required.”
fi
fi
}