mirrors/raspiblitz
1
0
Fork 0
mirror of https://github.com/rootzoll/raspiblitz.git synced 2025-02-25 15:10:38 +01:00
Code Issues Projects Releases Packages Wiki Activity
raspiblitz/home.admin/config.scripts/blitz.datadrive.sh
frennkie 3874ea014d
fix typo (#1145)
2020-04-28 15:31:00 +02:00

1414 lines
45 KiB
Bash
Raw Blame History

#!/bin/bash
if [ $# -eq 0 ] || [ "$1" = "-h" ] || [ "$1" = "-help" ]; then
>&2 echo "# managing the data drive(s) with old EXT4 or new BTRFS"
>&2 echo "# blitz.datadrive.sh [status|tempmount|format|fstab|raid|link|swap|clean|snapshot]"
echo "error='missing parameters'"
exit 1
fi
###################
# BASICS
###################
# TO UNDERSTAND THE BTFS HDD LAYOUT:
####################################
# 1) BLITZDATA - a BTRFS partion for all RaspiBlitz data - 30GB
# here put all files of LND, app, etc that need backup
# 2) BLITZSTORE - a BTFRS partion for mostly Blockchain data
# all data here can get lost and rebuild if needed (Blockchain, Indexes, etc)
# 3) BLITZTEMP - a FAT partition just for SWAP & Exchange - 34GB
# used for SWAP file and easy to read from Win32/MacOS for exchange
# this directory should get cleaned on every start (except from swap)
# check if started with sudo
if [ "$EUID" -ne 0 ]; then
echo "error='missing sudo'"
exit 1
fi
# install BTRFS if needed
btrfsInstalled=$(btrfs --version 2>/dev/null | grep -c "btrfs-progs")
if [ ${btrfsInstalled} -eq 0 ]; then
>&2 echo "# Installing BTRFS ..."
sudo apt-get install -y btrfs-tools 1>/dev/null
fi
btrfsInstalled=$(btrfs --version 2>/dev/null | grep -c "btrfs-progs")
if [ ${btrfsInstalled} -eq 0 ]; then
echo "error='missing btrfs package'"
exit 1
fi
###################
# STATUS
###################
# gathering system info
# is global so that also other parts of this script can use this
# basics
isMounted=$(sudo df | grep -c /mnt/hdd)
isBTRFS=$(sudo btrfs filesystem show 2>/dev/null| grep -c 'BLITZSTORAGE')
isRaid=$(btrfs filesystem df /mnt/hdd 2>/dev/null | grep -c "Data, RAID1")
isSSD=$(sudo cat /sys/block/sda/queue/rotational 2>/dev/null | grep -c 0)
# determine if swap is external on or not
externalSwapPath="/mnt/hdd/swapfile"
if [ ${isBTRFS} -eq 1 ]; then
externalSwapPath="/mnt/temp/swapfile"
fi
isSwapExternal=$(swapon -s | grep -c "${externalSwapPath}")
# output and exit if just status action
if [ "$1" = "status" ]; then
# optional second parameter can be 'bitcoin' or 'litecoin'
blockchainType=$2
echo "# RASPIBLITZ DATA DRIVE Status"
echo
echo "# BASICS"
echo "isMounted=${isMounted}"
echo "isBTRFS=${isBTRFS}"
echo "isSSD=${isBTRFS}"
# if HDD is not mounted system is in the pre-setup phase
# deliver all the detailes needed about the data drive
# and it content for the setup dialogs
if [ ${isMounted} -eq 0 ]; then
echo
echo "# SETUP INFO"
# find the HDD (biggest single device)
size=0
lsblk -o NAME | grep "^sd" | while read -r usbdevice ; do
testsize=$(lsblk -o NAME,SIZE -b | grep "^${usbdevice}" | awk '$1=$1' | cut -d " " -f 2)
if [ ${testsize} -gt ${size} ]; then
size=${testsize}
echo "${usbdevice}" > .hdd.tmp
fi
done
hdd=$(cat .hdd.tmp 2>/dev/null)
rm -f .hdd.tmp 1>/dev/null 2>/dev/null
echo "hddCandidate='${hdd}'"
if [ ${#hdd} -gt 0 ]; then
# check size in bytes and GBs
size=$(lsblk -o NAME,SIZE -b | grep "^${hdd}" | awk '$1=$1' | cut -d " " -f 2)
echo "hddBytes=${size}"
hddGigaBytes=$(echo "scale=0; ${size}/1024/1024/1024" | bc -l)
echo "hddGigaBytes=${hddGigaBytes}"
# check if single drive with that size
hddCount=$(lsblk -o NAME,SIZE -b | grep "^sd" | grep -c ${size})
echo "hddCount=${hddCount}"
# check format of devices first partition
hddFormat=$(lsblk -o FSTYPE,NAME,TYPE | grep part | grep "${hdd}1" | cut -d " " -f 1)
echo "hddFormat='${hddFormat}'"
# if 'ext4' or 'btrfs' then temp mount and investigate content
if [ "${hddFormat}" = "ext4" ] || [ "${hddFormat}" = "btrfs" ]; then
# BTRFS is working with subvolumnes for snapshots / ext4 has no SubVolumes
subVolumeDir=""
if [ "${hddFormat}" = "btrfs" ]; then
subVolumeDir="/WORKINGDIR"
fi
# temp mount data drive
mountError=""
sudo mkdir -p /mnt/hdd
if [ "${hddFormat}" = "ext4" ]; then
mountError=$(sudo mount /dev/${hdd}1 /mnt/hdd 2>&1)
fi
if [ "${hddFormat}" = "btrfs" ]; then
mountError=$(sudo mount -o degraded /dev/${hdd}1 /mnt/hdd 2>&1)
fi
isTempMounted=$(df | grep /mnt/hdd | grep -c ${hdd})
# check for mount error
if [ ${#mountError} -gt 0 ] || [ ${isTempMounted} -eq 0 ]; then
echo "hddError='data mount failed'"
# check for recoverable RaspiBlitz data (if config file exists) and raid
else
hddRaspiData=$(sudo ls -l /mnt/hdd${subVolumeDir} | grep -c raspiblitz.conf)
isRaid=$(btrfs filesystem df /mnt/hdd 2>/dev/null | grep -c "Data, RAID1")
echo "hddRaspiData=${hddRaspiData}"
sudo umount /mnt/hdd
fi
# temp storage data drive
sudo mkdir -p /mnt/storage
if [ "${hddFormat}" = "btrfs" ]; then
# in btrfs setup the second partition is storage partition
sudo mount /dev/${hdd}2 /mnt/storage 2>/dev/null
else
# in ext4 setup the first partition is also the storage partition
sudo mount /dev/${hdd}1 /mnt/storage 2>/dev/null
fi
isTempMounted=$(df | grep /mnt/storage | grep -c ${hdd})
if [ ${isTempMounted} -eq 0 ]; then
echo "hddError='storage mount failed'"
else
# check for blockchain data on storage
hddBlocksBitcoin=$(sudo ls /mnt/storage${subVolumeDir}/bitcoin/blocks/blk00000.dat 2>/dev/null | grep -c '.dat')
echo "hddBlocksBitcoin=${hddBlocksBitcoin}"
hddBlocksLitecoin=$(sudo ls /mnt/storage${subVolumeDir}/litecoin/blocks/blk00000.dat 2>/dev/null | grep -c '.dat')
echo "hddBlocksLitecoin=${hddBlocksLitecoin}"
sudo umount /mnt/storage
if [ "${blockchainType}" = "bitcoin" ] && [ ${hddBlocksBitcoin} -eq 1 ]; then
echo "hddGotBlockchain=1"
elif [ "${blockchainType}" = "litecoin" ] && [ ${hddBlocksLitecoin} -eq 1 ]; then
echo "hddGotBlockchain=1"
elif [ ${#blockchainType} -gt 0 ]; then
echo "hddGotBlockchain=0"
fi
fi
else
# if not ext4 or btrfs - there is no usable data
echo "hddRaspiData=0"
echo "hddBlocksBitcoin=0"
echo "hddBlocksLitecoin=0"
echo "hddGotBlockchain=0"
fi
fi
else
# STATUS INFO WHEN MOUNTED
# output data drive
hdd=$(df | grep "/mnt/hdd" | cut -d " " -f 1 | cut -d "/" -f 3 | sed 's/[0-9]*//g')
echo "datadisk='${hdd}'"
# check if blockchain data is available
hddBlocksBitcoin=$(sudo ls /mnt/hdd/bitcoin/blocks/blk00000.dat 2>/dev/null | grep -c '.dat')
echo "hddBlocksBitcoin=${hddBlocksBitcoin}"
hddBlocksLitecoin=$(sudo ls /mnt/hdd/litecoin/blocks/blk00000.dat 2>/dev/null | grep -c '.dat')
echo "hddBlocksLitecoin=${hddBlocksLitecoin}"
if [ "${blockchainType}" = "bitcoin" ] && [ ${hddBlocksBitcoin} -eq 1 ]; then
echo "hddGotBlockchain=1"
elif [ "${blockchainType}" = "litecoin" ] && [ ${hddBlocksLitecoin} -eq 1 ]; then
echo "hddGotBlockchain=1"
elif [ ${#blockchainType} -gt 0 ]; then
echo "hddGotBlockchain=0"
fi
# check size in bytes and GBs
size=$(lsblk -o NAME,SIZE -b | grep "^${hdd}" | awk '$1=$1' | cut -d " " -f 2)
echo "hddBytes=${size}"
hddGigaBytes=$(echo "scale=0; ${size}/1024/1024/1024" | bc -l)
echo "hddGigaBytes=${hddGigaBytes}"
# used space - at the moment just string info to display
if [ ${isBTRFS} -eq 0 ]; then
# EXT4 calculations
hdd_used_space=$(df -h | grep "/dev/${hdd}" | sed -e's/ */ /g' | cut -d" " -f 3 2>/dev/null)
hdd_used_ratio=$(df -h | grep "/dev/${hdd}" | sed -e's/ */ /g' | cut -d" " -f 5 | tr -dc '0-9' 2>/dev/null)
hddUsedInfo="${hdd_used_space} (${hdd_used_ratio}%)"
else
# BRTS calculations
# TODO: this is the final/correct way - make better later
# https://askubuntu.com/questions/170044/btrfs-and-missing-free-space
datadrive=$(df -h | grep "/dev/${hdd}1" | sed -e's/ */ /g' | cut -d" " -f 5)
storageDrive=$(df -h | grep "/dev/${hdd}2" | sed -e's/ */ /g' | cut -d" " -f 5)
hddUsedInfo="${datadrive} & ${storageDrive}"
fi
echo "hddUsedInfo='${hddUsedInfo}'"
fi
echo
echo "# RAID"
echo "isRaid=${isRaid}"
if [ ${isRaid} -eq 1 ] && [ ${isMounted} -eq 1 ] && [ ${isBTRFS} -eq 1 ]; then
# RAID is ON - give information about running raid setup
# show devices used for raid
raidHddDev=$(lsblk -o NAME,MOUNTPOINT | grep "/mnt/hdd" | awk '$1=$1' | cut -d " " -f 1 | sed 's/[^0-9a-z]*//g')
raidUsbDev=$(sudo btrfs filesystem show /mnt/hdd | grep -F -v "${raidHddDev}" | grep "/dev/" | cut -d "/" --f 3)
echo "raidHddDev='${raidHddDev}'"
echo "raidUsbDev='${raidUsbDev}'"
else
# RAID is OFF - give information about possible drives to activate
# find the possible drives that can be used as
drivecounter=0
for disk in $(lsblk -o NAME,TYPE | grep "disk" | awk '$1=$1' | cut -d " " -f 1)
do
devMounted=$(lsblk -o MOUNTPOINT,NAME | grep "$disk" | grep -c "^/")
# is raid candidate when not mounted and not the data drive cadidate (hdd/ssd)
if [ ${devMounted} -eq 0 ] && [ "${disk}" != "${hdd}" ]; then
sizeBytes=$(lsblk -o NAME,SIZE -b | grep "^${disk}" | awk '$1=$1' | cut -d " " -f 2)
sizeGigaBytes=$(echo "scale=0; ${sizeBytes}/1024/1024/1024" | bc -l)
vedorname=$(lsblk -o NAME,VENDOR | grep "^${disk}" | awk '$1=$1' | cut -d " " -f 2)
mountoption="${disk} ${sizeGigaBytes} GB ${vedorname}"
echo "raidCandidate[${drivecounter}]='${mountoption}'"
drivecounter=$(($drivecounter +1))
fi
done
echo "raidCandidates=${drivecounter}"
fi
echo
echo "# SWAP"
echo "isSwapExternal=${isSwapExternal}"
if [ ${isSwapExternal} -eq 1 ]; then
echo "SwapExternalPath='${externalSwapPath}'"
fi
echo
exit 1
fi
######################
# FORMAT EXT4 or BTRFS
######################
# check basics for formating
if [ "$1" = "format" ]; then
# check valid format
if [ "$2" = "btrfs" ]; then
>&2 echo "# DATA DRIVE - FORMATTING to new BTRFS layout (new)"
elif [ "$2" = "ext4" ]; then
>&2 echo "# DATA DRIVE - FORMATTING to new EXT4 layout (old)"
else
>&2 echo "# missing valid second parameter: 'btrfs' or 'ext4'"
echo "error='missing parameter'"
exit 1
fi
# get device name to format
hdd=$3
if [ ${#hdd} -eq 0 ]; then
>&2 echo "# missing valid third parameter as the device (like 'sda')"
>&2 echo "# run 'status' to see cadidate devices"
echo "error='missing parameter'"
exit 1
fi
# check if device is existing and a disk (not a partition)
isValid=$(lsblk -o NAME,TYPE | grep disk | grep -c "${hdd}")
if [ ${isValid} -eq 0 ]; then
>&2 echo "# either given device was not found"
>&2 echo "# or is not of type disk - see 'lsblk'"
echo "error='device not valid'"
exit 1
fi
# get basic info on data drives
source <(sudo /home/admin/config.scripts/blitz.datadrive.sh status)
if [ ${isSwapExternal} -eq 1 ] && [ "${hdd}" == "${datadisk}" ]; then
>&2 echo "# Switching off external SWAP of system drive"
sudo dphys-swapfile swapoff 1>/dev/null
sudo dphys-swapfile uninstall 1>/dev/null
fi
>&2 echo "# Unmounting all partitions of this device"
# remove device from all system mounts (also fstab)
lsblk -o NAME,UUID | grep "${hdd}" | awk '$1=$1' | cut -d " " -f 2 | grep "-" | while read -r uuid ; do
>&2 echo "# Cleaning /etc/fstab from ${uuid}"
sudo sed -i "/UUID=${uuid}/d" /etc/fstab
sync
done
sudo mount -a
if [ "${hdd}" == "${datadisk}" ]; then
>&2 echo "# Make sure system drives are unmounted .."
sudo umount /mnt/hdd 2>/dev/null
sudo umount /mnt/temp 2>/dev/null
sudo umount /mnt/storage 2>/dev/null
unmounted1=$(df | grep -c "/mnt/hdd")
if [ ${unmounted1} -gt 0 ]; then
echo "error='failed to unmount /mnt/hdd'"
exit 1
fi
unmounted2=$(df | grep -c "/mnt/temp")
if [ ${unmounted2} -gt 0 ]; then
echo "error='failed to unmount /mnt/temp'"
exit 1
fi
unmounted3=$(df | grep -c "/mnt/storage")
if [ ${unmounted3} -gt 0 ]; then
echo "error='failed to unmount /mnt/storage'"
exit 1
fi
fi
# wipe all partitions and write fresh GPT
>&2 echo "# Wiping all partitions"
for v_partition in $(parted -s /dev/${hdd} print|awk '/^ / {print $1}')
do
sudo parted -s /dev/${hdd} rm ${v_partition}
sleep 2
done
partitions=$(lsblk | grep -c "─${hdd}")
if [ ${partitions} -gt 0 ]; then
echo "error='partition cleaning failed'"
exit 1
fi
sudo parted -s /dev/${hdd} mklabel gpt 1>/dev/null
sleep 2
sync
fi
# formatting old: EXT4
if [ "$1" = "format" ] && [ "$2" = "ext4" ]; then
# prepare temp mount point
sudo mkdir -p /tmp/ext4 1>/dev/null
# write new EXT4 partition
>&2 echo "# Creating the one big partition"
sudo parted /dev/${hdd} mkpart primary ext4 0% 100% 1>/dev/null 2>/dev/null
sleep 6
sync
# loop until the partion gets available
done=0
loopcount=0
while [ ${done} -eq 0 ]
do
>&2 echo "# waiting until the partion gets available"
sleep 2
sync
done=$(lsblk -o NAME | grep -c ${hdd}1)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 10 ]; then
echo "error='partition failed'"
exit 1
fi
done
# make sure /mnt/hdd is unmounted before formatting
sudo umount -f /tmp/ext4 2>/dev/null
unmounted=$(df | grep -c "/tmp/ext4")
if [ ${unmounted} -gt 0 ]; then
echo "error='failed to unmount /tmp/ext4'"
exit 1
fi
>&2 echo "# Formatting"
sudo mkfs.ext4 -F -L BLOCKCHAIN /dev/${hdd}1 1>/dev/null
done=0
loopcount=0
while [ ${done} -eq 0 ]
do
>&2 echo "# waiting until formatted drives gets available"
sleep 2
sync
done=$(lsblk -o NAME,LABEL | grep -c BLOCKCHAIN)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 10 ]; then
echo "error='formatting ext4 failed'"
exit 1
fi
done
# setting fsk check intervall to 1
# see https://github.com/rootzoll/raspiblitz/issues/360#issuecomment-467567572
sudo tune2fs -c 1 /dev/${hdd}1
>&2 echo "# OK EXT 4 format done"
exit 0
fi
# formatting new: BTRFS layout - this consists of 3 volmunes:
if [ "$1" = "format" ] && [ "$2" = "btrfs" ]; then
# prepare temo mount point
sudo mkdir -p /tmp/btrfs 1>/dev/null
>&2 echo "# Creating BLITZDATA"
sudo parted -s -a optimal -- /dev/${hdd} mkpart primary btrfs 0% 30GiB 1>/dev/null
sync && sleep 3
win=$(lsblk -o NAME | grep -c ${hdd}1)
if [ ${win} -eq 0 ]; then
echo "error='partition failed'"
exit 1
fi
sudo mkfs.btrfs -f -L BLITZDATA /dev/${hdd}1 1>/dev/null
sync && sleep 3
win=$(lsblk -o NAME,LABEL | grep -c BLITZDATA)
if [ ${win} -eq 0 ]; then
echo "error='formatting failed'"
exit 1
fi
>&2 echo "# OK BLITZDATA exists now"
>&2 echo "# Creating SubVolume for Snapshots"
sudo mount /dev/${hdd}1 /tmp/btrfs 1>/dev/null
if [ $(df | grep -c "/tmp/btrfs") -eq 0 ]; then
echo "error='mount ${hdd}1 failed'"
exit 1
fi
cd /tmp/btrfs
sudo btrfs subvolume create WORKINGDIR
subVolDATA=$(sudo btrfs subvolume show /tmp/btrfs/WORKINGDIR | grep "Subvolume ID:" | awk '$1=$1' | cut -d " " -f 3)
cd && sudo umount /tmp/btrfs
>&2 echo "# Creating BLITZSTORAGE"
sudo parted -s -a optimal -- /dev/${hdd} mkpart primary btrfs 30GiB -34GiB 1>/dev/null
sync && sleep 3
win=$(lsblk -o NAME | grep -c ${hdd}2)
if [ ${win} -eq 0 ]; then
echo "error='partition failed'"
exit 1
fi
sudo mkfs.btrfs -f -L BLITZSTORAGE /dev/${hdd}2 1>/dev/null
sync && sleep 3
win=$(lsblk -o NAME,LABEL | grep -c BLITZSTORAGE)
if [ ${win} -eq 0 ]; then
echo "error='formatting failed'"
exit 1
fi
>&2 echo "# OK BLITZSTORAGE exists now"
>&2 echo "# Creating SubVolume for Snapshots"
sudo mount /dev/${hdd}2 /tmp/btrfs 1>/dev/null
if [ $(df | grep -c "/tmp/btrfs") -eq 0 ]; then
echo "error='mount ${hdd}2 failed'"
exit 1
fi
cd /tmp/btrfs
sudo btrfs subvolume create WORKINGDIR
cd && sudo umount /tmp/btrfs
>&2 echo "# Creating the FAT32 partion"
sudo parted -s -a optimal -- /dev/${hdd} mkpart primary fat32 -34GiB 100% 1>/dev/null
sync && sleep 3
win=$(lsblk -o NAME | grep -c ${hdd}3)
if [ ${win} -eq 0 ]; then
echo "error='partition failed'"
exit 1
fi
>&2 echo "# Creating Volume BLITZTEMP (format)"
sudo mkfs -t vfat -n BLITZTEMP /dev/${hdd}3 1>/dev/null
sync && sleep 3
win=$(lsblk -o NAME,LABEL | grep -c BLITZTEMP)
if [ ${win} -eq 0 ]; then
echo "error='formatting failed'"
exit 1
fi
>&2 echo "# OK BLITZTEMP exists now"
>&2 echo "# OK BTRFS format done"
exit 0
fi
########################################
# Refresh FSTAB for permanent mount
########################################
if [ "$1" = "fstab" ]; then
# get device to temp mount
hdd=$2
if [ ${#hdd} -eq 0 ]; then
>&2 echo "# FAIL which device should be temp mounted (e.g. sda)"
>&2 echo "# run 'status' to see device candidates"
echo "error='missing second parameter'"
exit 1
fi
# check is exist and which format
hddFormat=$(lsblk -o FSTYPE,NAME | grep ${hdd}1 | cut -d ' ' -f 1)
if [ ${#hddFormat} -eq 0 ]; then
>&2 echo "# FAIL given device not found"
echo "error='device not found'"
exit 1
fi
# unmount
if [ ${isMounted} -eq 1 ]; then
>&2 echo "# unmounting all drives"
sudo umount /mnt/hdd 2>/dev/null
sudo umount /mnt/storage 2>/dev/null
sudo umount /mnt/temp 2>/dev/null
fi
if [ "${hddFormat}" = "ext4" ]; then
### EXT4 ###
# loop until the uuids are available
uuid1=""
loopcount=0
while [ ${#uuid1} -eq 0 ]
do
>&2 echo "# waiting until uuid gets available"
sleep 2
sync
uuid1=$(lsblk -o NAME,UUID | grep "${hdd}" | awk '$1=$1' | cut -d " " -f 2 | grep "-")
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 10 ]; then
echo "error='no uuid'"
exit 1
fi
done
# write new /etc/fstab & mount
>&2 echo "# updating /etc/fstab & mount"
sudo mkdir -p /mnt/hdd 1>2&
sudo sed "3 a UUID=${uuid1} /mnt/hdd ext4 noexec,defaults 0 2" -i /etc/fstab 1>/dev/null
sync
sudo mount -a 1>/dev/null
# loop mounts are available
mountactive1=0
loopcount=0
while [ ${mountactive1} -eq 0 ]
do
>&2 echo "# waiting until mounting is active"
sleep 2
sync
mountactive1=$(df | grep -c /mnt/hdd)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 10 ]; then
>&2 echo "# WARNING was not able freshly mount new devives - might need reboot or check /etc/fstab"
echo "needsReboot=1"
exit 0
fi
done
>&2 echo "# OK - fstab updated for EXT4 layout"
exit 1
elif [ "${hddFormat}" = "btrfs" ]; then
### BTRFS ###
>&2 echo "# BTRFS: Updating /etc/fstab & mount"
# get info on: Data Drive
uuidDATA=$(lsblk -o UUID,NAME,LABEL | grep "${hdd}" | grep "BLITZDATA" | cut -d " " -f 1 | grep "-")
sudo mkdir -p /tmp/btrfs
sudo mount /dev/${hdd}1 /tmp/btrfs 1>/dev/null
if [ $(df | grep -c "/tmp/btrfs") -eq 0 ]; then
echo "error='mount ${hdd}1 failed'"
exit 1
fi
cd /tmp/btrfs
subVolDATA=$(sudo btrfs subvolume show /tmp/btrfs/WORKINGDIR | grep "Subvolume ID:" | awk '$1=$1' | cut -d " " -f 3)
cd && sudo umount /tmp/btrfs
echo "uuidDATA='${uuidDATA}'"
echo "subVolDATA='${subVolDATA}'"
if [ ${#uuidDATA} -eq 0 ] || [ ${#subVolDATA} -eq 0 ]; then
echo "error='no datadrive uuids'"
exit 1
fi
# get info on: Storage Drive
uuidSTORAGE=$(lsblk -o UUID,NAME,LABEL | grep "${hdd}" | grep "BLITZSTORAGE" | cut -d " " -f 1 | grep "-")
sudo mount /dev/${hdd}2 /tmp/btrfs 1>/dev/null
if [ $(df | grep -c "/tmp/btrfs") -eq 0 ]; then
echo "error='mount ${hdd}2 failed'"
exit 1
fi
cd /tmp/btrfs
subVolSTORAGE=$(sudo btrfs subvolume show /tmp/btrfs/WORKINGDIR | grep "Subvolume ID:" | awk '$1=$1' | cut -d " " -f 3)
cd && sudo umount /tmp/btrfs
echo "uuidSTORAGE='${uuidSTORAGE}'"
echo "subVolSTORAGE='${subVolSTORAGE}'"
if [ ${#uuidSTORAGE} -eq 0 ] || [ ${#subVolSTORAGE} -eq 0 ]; then
echo "error='no storagedrive uuids'"
exit 1
fi
# get info on: Temp Drive
uuidTEMP=$(lsblk -o LABEL,UUID | grep "BLITZTEMP" | awk '$1=$1' | cut -d " " -f 2 | grep "-")
echo "uuidTEMP='${uuidTEMP}'"
if [ ${#uuidTEMP} -eq 0 ]; then
echo "error='no tempdrive uuids'"
exit 1
fi
# remove old entries from fstab
lsblk -o NAME,UUID | grep "${hdd}" | awk '$1=$1' | cut -d " " -f 2 | grep "-" | while read -r uuid ; do
>&2 echo "# Cleaning /etc/fstab from ${uuid}"
sudo sed -i "/UUID=${uuid}/d" /etc/fstab
sync
done
# get user and grouid if usr/group bitcoin
bitcoinUID=$(id -u bitcoin)
bitcoinGID=$(id -g bitcoin)
# modifying /etc/fstab & mount
sudo mkdir -p /mnt/hdd 1>/dev/null
fstabAdd1="UUID=${uuidDATA} /mnt/hdd btrfs noexec,defaults,subvolid=${subVolDATA} 0 2"
sudo sed "3 a ${fstabAdd1}" -i /etc/fstab 1>/dev/null
sudo mkdir -p /mnt/storage 1>/dev/null
fstabAdd2="UUID=${uuidSTORAGE} /mnt/storage btrfs noexec,defaults,subvolid=${subVolSTORAGE} 0 2"
sudo sed "4 a ${fstabAdd2}" -i /etc/fstab 1>/dev/null
sudo mkdir -p /mnt/temp 1>/dev/null
fstabAdd3="UUID=${uuidTEMP} /mnt/temp vfat noexec,defaults,uid=${bitcoinUID},gid=${bitcoinGID} 0 2"
sudo sed "5 a ${fstabAdd3}" -i /etc/fstab 1>/dev/null
sync && sudo mount -a 1>/dev/null
# test mount
mountactive1=0
mountactive2=0
mountactive3=0
loopcount=0
while [ ${mountactive1} -eq 0 ] || [ ${mountactive2} -eq 0 ] || [ ${mountactive3} -eq 0 ]
do
>&2 echo "# waiting until mountings are active"
sleep 2
sync
mountactive1=$(df | grep -c /mnt/hdd)
mountactive2=$(df | grep -c /mnt/temp)
mountactive3=$(df | grep -c /mnt/storage)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 10 ]; then
>&2 echo "# WARNING was not able freshly mount new devives - might need reboot or check /etc/fstab"
echo "needsReboot=1"
exit 1
fi
done
>&2 echo "# OK - fstab updated for BTRFS layout"
exit 1
else
echo "error='wrong hdd format'"
exit 1
fi
fi
########################################
# RAID with USB Stick for data partition
########################################
if [ "$1" = "raid" ]; then
# checking if BTRFS mode
if [ ${isBTRFS} -eq 0 ]; then
echo "error='raid only BTRFS'"
exit 1
fi
# checking parameter
if [ "$2" = "on" ]; then
if [ ${isRaid} -eq 1 ]; then
>&2 echo "# OK - already ON"
exit
fi
>&2 echo "# RAID - Adding raid drive to RaspiBlitz data drive"
elif [ "$2" = "off" ]; then
>&2 echo "# RAID - Removing raid drive to RaspiBlitz data drive"
else
>&2 echo "# possible 2nd parameter is 'on' or 'off'"
echo "error='unkown parameter'"
exit 1
fi
fi
# RAID --> ON
if [ "$1" = "raid" ] && [ "$2" = "on" ]; then
# todo - how to determine which device is the usb raid to add
# maybe give all options with "status" and have this as
# second parameter - like its named: lsblk
usbdev=$3
if [ ${#usbdev} -eq 0 ]; then
>&2 echo "# FAIL third parameter is missing with the name of the usb device to add"
echo "error='missing parameter'"
exit 1
fi
# check that dev exists and is unique
usbdevexists=$(lsblk -o NAME,UUID | grep -c "^${usbdev}")
if [ ${usbdevexists} -eq 0 ]; then
>&2 echo "# FAIL not found: ${usbdev}"
echo "error='dev not found'"
exit 1
fi
if [ ${usbdevexists} -gt 1 ]; then
>&2 echo "# FAIL multiple matches: ${usbdev}"
echo "error='dev not unique'"
exit 1
fi
# check that device is a disk and not a partition
isDisk=$(lsblk -o NAME,TYPE | grep "^${usbdev}" | grep -c disk)
if [ ${isDisk} -eq 0 ]; then
echo "error='dev is not disk'"
exit 1
fi
# check that device is not mounted
if [ $(df | cut -d " " -f 1 | grep -c "/${usbdev}") -gt 0 ]; then
echo "error='dev is in use'"
exit 1
fi
# check if old BTRFS filesystem
usbdevBTRFS=$(lsblk -o NAME,UUID,FSTYPE | grep "^${usbdev}" | grep -c "btrfs")
if [ ${usbdevBTRFS} -eq 1 ]; then
# edge case: already contains BTRFS data
# TODO: once implemented -> also make sure that dev1 is named "DATASTORE" and if 2nd is other -> format and add as raid
>&2 echo "# ERROR: !! NOT IMPLEMENTED YET -> devices seem contain old data"
>&2 echo "# if you dont care about that data: format on other computer with FAT"
echo "error='old data on dev'"
exit 1
fi
# remove all partions from device
for v_partition in $(parted -s /dev/${usbdev} print|awk '/^ / {print $1}')
do
sudo parted -s /dev/${usbdev} rm ${v_partition}
done
# check if usb device is at least 30GB groß
usbdevsize=$(lsblk -o NAME,SIZE -b | grep "^${usbdev}" | awk '$1=$1' | cut -d " " -f 2)
if [ ${usbdevsize} -lt 30000000000 ]; then
>&2 echo "# FAIL ${usbdev} is smaller then the minumum 30GB"
echo "error='dev too small'"
exit 1
fi
# add usb device as raid for data
>&2 echo "# adding ${usbdev} as BTRFS raid1 for /mnt/hdd"
sudo btrfs device add -f /dev/${usbdev} /mnt/hdd 1>/dev/null
sudo btrfs filesystem balance start -dconvert=raid1 -mconvert=raid1 /mnt/hdd 1>/dev/null
>&2 echo "# OK - ${usbdev} is now part of a RAID1 for your RaspiBlitz data"
exit 0
fi
# RAID --> OFF
if [ "$1" = "raid" ] && [ "$2" = "off" ]; then
# checking if BTRFS mode
isBTRFS=$(sudo btrfs filesystem show 2>/dev/null| grep -c 'BLITZSTORAGE')
if [ ${isBTRFS} -eq 0 ]; then
echo "error='raid only BTRFS'"
exit 1
fi
deviceToBeRemoved="/dev/${raidUsbDev}"
# just in case be able to remove missing drive
if [ ${#raidUsbDev} -eq 0 ]; then
deviceToBeRemoved="missing"
fi
>&2 echo "# removing USB DEV from RAID"
sudo btrfs balance start -mconvert=dup -dconvert=single /mnt/hdd 1>/dev/null
sudo btrfs device remove ${deviceToBeRemoved} /mnt/hdd 1>/dev/null
isRaid=$(btrfs filesystem df /mnt/hdd 2>/dev/null | grep -c "Data, RAID1")
if [ ${isRaid} -eq 0 ]; then
>&2 echo "# OK - RaspiBlitz data is not running in RAID1 anymore"
exit 0
else
>&2 echo "# FAIL - was not able to remove RAID device"
echo "error='fail'"
exit 1
fi
fi
########################################
# SNAPSHOTS - make and replay
########################################
if [ "$1" = "snapshot" ]; then
# check if data drive is mounted
if [ ${isMounted} -eq 0 ]; then
echo "error='no data drive mounted'"
exit 1
fi
# check if BTRFS
if [ ${isBTRFS} -eq 0 ]; then
echo "error='no BTRFS'"
exit 1
fi
# SECOND PARAMETER: 'data' or 'storage'
if [ "$2" = "data" ]; then
subvolume="/mnt/hdd"
subvolumeESC="\/mnt\/hdd"
uuid=$(lsblk -o LABEL,UUID | grep "BLITZDATA" | awk '$1=$1' | cut -d " " -f 2 | grep "-")
elif [ "$2" = "storage" ]; then
subvolume="/mnt/storage"
subvolumeESC="\/mnt\/storage"
uuid=$(lsblk -o LABEL,UUID | grep "BLITZSTORAGE" | awk '$1=$1' | cut -d " " -f 2 | grep "-")
else
>&2 echo "# second parameter needs to be 'data' or 'storage'"
echo "error='unknown parameter'"
exit 1
fi
>&2 echo "# RASPIBLITZ SNAPSHOTS"
partition=$(df | grep "${subvolume}" | cut -d " " -f 1)
echo "subvolume='${subvolume}'"
echo "partition='${partition}'"
if [ "$3" = "create" ]; then
>&2 echo "# Preparing Snapshot ..."
# make sure backup folder exists
sudo mkdir -p ${subvolume}/snapshots
# delete old backup if existing
oldBackupExists=$(sudo ls ${subvolume}/snapshots | grep -c backup)
if [ ${oldBackupExists} -gt 0 ]; then
>&2 echo "# Deleting old snapshot"
sudo btrfs subvolume delete ${subvolume}/snapshots/backup 1>/dev/null
fi
>&2 echo "# Creating Snapshot ..."
sudo btrfs subvolume snapshot ${subvolume} ${subvolume}/snapshots/backup 1>/dev/null
if [ $(sudo btrfs subvolume list ${subvolume} | grep -c snapshots/backup) -eq 0 ]; then
echo "error='not created'"
exit 1
else
>&2 echo "# OK - Snapshot created"
exit 0
fi
elif [ "$3" = "rollback" ]; then
# check if an old snapshot exists
oldBackupExists=$(sudo ls ${subvolume}/snapshots | grep -c backup)
if [ ${oldBackupExists} -eq 0 ]; then
echo "error='no old snapshot found'"
exit 1
fi
>&2 echo "# Resetting state to old Snapshot ..."
sudo umount ${subvolume}
sudo mkdir -p /tmp/btrfs 1>/dev/null
sudo mount ${partition} /tmp/btrfs
sudo mv /tmp/btrfs/WORKINGDIR/snapshots/backup /tmp/btrfs/backup
sudo btrfs subvolume delete /tmp/btrfs/WORKINGDIR
sudo mv /tmp/btrfs/backup /tmp/btrfs/WORKINGDIR
subVolID=$(sudo btrfs subvolume show /tmp/btrfs/WORKINGDIR | grep "Subvolume ID:" | awk '$1=$1' | cut -d " " -f 3)
sudo sed -i "/${subvolumeESC}/d" /etc/fstab
fstabAdd="UUID=${uuid} ${subvolume} btrfs noexec,defaults,subvolid=${subVolID} 0 2"
sudo sed "4 a ${fstabAdd}" -i /etc/fstab 1>/dev/null
sudo umount /tmp/btrfs
sudo mount -a
sync
if [ $(df | grep -c "${subvolume}") -eq 0 ]; then
>&2 echo "# check drive setting ... rollback seemed to "
echo "error='failed rollback'"
exit 1
fi
echo "OK - Rollback done"
exit 0
else
>&2 echo "# third parameter needs to be 'create' or 'rollback'"
echo "error='unknown parameter'"
exit 1
fi
fi
###################
# TEMP MOUNT
###################
if [ "$1" = "tempmount" ]; then
if [ ${isMounted} -eq 1 ]; then
echo "error='already mounted'"
exit 1
fi
# get device to temp mount
hdd=$2
if [ ${#hdd} -eq 0 ]; then
>&2 echo "# FAIL which device should be temp mounted (e.g. sda)"
>&2 echo "# run 'status' to see device candidates"
echo "error='missing second parameter'"
exit 1
fi
hddFormat=$(lsblk -o FSTYPE,NAME | grep ${hdd}1 | cut -d ' ' -f 1)
if [ ${#hddFormat} -eq 0 ]; then
>&2 echo "# FAIL given device not found"
echo "error='device not found'"
exit 1
fi
if [ "${hddFormat}" = "ext4" ]; then
# do EXT4 temp mount
sudo mkdir -p /mnt/hdd 1>/dev/null
sudo mount /dev/${hdd}1 /mnt/hdd
# check result
isMounted=$(df | grep -c "/mnt/hdd")
if [ ${isMounted} -eq 0 ]; then
echo "error='temp mount failed'"
exit 1
else
isMounted=1
isBTRFS=0
fi
elif [ "${hddFormat}" = "btrfs" ]; then
# get user and grouid if usr/group bitcoin
bitcoinUID=$(id -u bitcoin)
bitcoinGID=$(id -g bitcoin)
# do BTRFS temp mount
sudo mkdir -p /mnt/hdd 1>/dev/null
sudo mkdir -p /mnt/storage 1>/dev/null
sudo mkdir -p /mnt/temp 1>/dev/null
sudo mount -t btrfs -o degraded -o subvol=WORKINGDIR /dev/${hdd}1 /mnt/hdd
sudo mount -t btrfs -o subvol=WORKINGDIR /dev/${hdd}2 /mnt/storage
sudo mount -o uid=${bitcoinUID},gid=${bitcoinGID} /dev/${hdd}3 /mnt/temp
# check result
isMountedA=$(df | grep -c "/mnt/hdd")
isMountedB=$(df | grep -c "/mnt/storage")
isMountedC=$(df | grep -c "/mnt/temp")
if [ ${isMountedA} -eq 0 ] && [ ${isMountedB} -eq 0 ] && [ ${isMountedC} -eq 0 ]; then
echo "error='temp mount failed'"
exit 1
else
isMounted=1
isBTRFS=1
fi
else
echo "error='no supported hdd format'"
exit 1
fi
# outputting change state
echo "isMounted=${isMounted}"
echo "isBTRFS=${isBTRFS}"
exit 1
fi
########################################
# LINKING all directories with ln
########################################
if [ "$1" = "link" ]; then
if [ ${isMounted} -eq 0 ] ; then
echo "error='no data drive mounted'"
exit 1
fi
# cleanups
if [ $(sudo ls -la /home/bitcoin/ | grep -c "bitcoin ->") -eq 0 ]; then
>&2 echo "# - /home/bitcoin/.bitcoin -> is not a link, cleaning"
sudo rm -r /home/bitcoin/.bitcoin 2>/dev/null
else
sudo rm /home/bitcoin/.bitcoin 2>/dev/null
fi
if [ $(sudo ls -la /home/bitcoin/ | grep -c "litecoin ->") -eq 0 ]; then
>&2 echo "# - /home/bitcoin/.litecoin -> is not a link, cleaning"
sudo rm -r /home/bitcoin/.litecoin 2>/dev/null
else
sudo rm /home/bitcoin/.litecoin 2>/dev/null
fi
# make sure common base directory exits
sudo mkdir -p /mnt/hdd/lnd
sudo mkdir -p /mnt/hdd/app-data
if [ ${isBTRFS} -eq 1 ]; then
>&2 echo "# Creating BTRFS setup links"
>&2 echo "# - linking blockchains into /mnt/hdd"
if [ $(ls /mnt/hdd/bitcoin 2>/dev/null | grep -c 'bitcoin') -eq 0 ]; then
sudo mkdir -p /mnt/storage/bitcoin
sudo chown -R bitcoin:bitcoin /mnt/storage/bitcoin
sudo ln -s /mnt/storage/bitcoin /mnt/hdd/bitcoin
sudo rm /mnt/storage/bitcoin/bitcoin 2>/dev/null
fi
if [ $(ls /mnt/hdd/litecoin 2>/dev/null | grep -c 'litecoin') -eq 0 ]; then
sudo mkdir -p /mnt/storage/litecoin
sudo chown -R bitcoin:bitcoin /mnt/storage/litecoin
sudo ln -s /mnt/storage/litecoin /mnt/hdd/litecoin
sudo rm /mnt/storage/litecoin/litecoin 2>/dev/null
fi
>&2 echo "# linking lnd for user bitcoin"
sudo rm /home/bitcoin/.lnd 2>/dev/null
sudo ln -s /mnt/hdd/lnd /home/bitcoin/.lnd
>&2 echo "# - linking blockchain for user bitcoin"
sudo ln -s /mnt/storage/bitcoin /home/bitcoin/.bitcoin
sudo ln -s /mnt/storage/litecoin /home/bitcoin/.litecoin
>&2 echo "# - linking storage into /mnt/hdd"
sudo mkdir -p /mnt/storage/app-storage
sudo chown -R bitcoin:bitcoin /mnt/storage/app-storage
sudo rm /mnt/hdd/app-storage 2>/dev/null
sudo ln -s /mnt/storage/app-storage /mnt/hdd/app-storage
>&2 echo "# - linking temp into /mnt/hdd"
sudo rm /mnt/hdd/temp 2>/dev/null
sudo ln -s /mnt/temp /mnt/hdd/temp
sudo chown -R bitcoin:bitcoin /mnt/temp
>&2 echo "# - creating snapshots folder"
sudo mkdir -p /mnt/hdd/snapshots
sudo mkdir -p /mnt/storage/snapshots
else
>&2 echo "# Creating EXT4 setup links"
>&2 echo "# opening blockchain into /mnt/hdd"
sudo mkdir -p /mnt/hdd/bitcoin
sudo mkdir -p /mnt/hdd/litecoin
>&2 echo "# linking blockchain for user bitcoin"
sudo rm /home/bitcoin/.bitcoin 2>/dev/null
sudo ln -s /mnt/hdd/bitcoin /home/bitcoin/.bitcoin
sudo rm /home/bitcoin/.litecoin 2>/dev/null
sudo ln -s /mnt/hdd/litecoin /home/bitcoin/.litecoin
>&2 echo "# linking lnd for user bitcoin"
sudo rm /home/bitcoin/.lnd 2>/dev/null
sudo ln -s /mnt/hdd/lnd /home/bitcoin/.lnd
>&2 echo "# creating default storage & temp folders"
sudo mkdir -p /mnt/hdd/app-storage
sudo mkdir -p /mnt/hdd/temp
fi
# fix ownership of linked files
sudo chown -R bitcoin:bitcoin /mnt/hdd/bitcoin
sudo chown -R bitcoin:bitcoin /mnt/hdd/litecoin
sudo chown -R bitcoin:bitcoin /mnt/hdd/lnd
sudo chown -R bitcoin:bitcoin /home/bitcoin/.lnd
sudo chown -R bitcoin:bitcoin /home/bitcoin/.litecoin
sudo chown -R bitcoin:bitcoin /home/bitcoin/.bitcoin
sudo chown -R bitcoin:bitcoin /mnt/hdd/app-storage
sudo chown -R bitcoin:bitcoin /mnt/hdd/app-data
sudo chown -R bitcoin:bitcoin /mnt/hdd/temp
sudo chmod -R 766 /mnt/hdd/temp
# write info files about what directories are for
echo "The /mnt/hdd/temp directory is for short time data and will get cleaned up on very start. Dont work with data here thats bigger then 25GB - because on BTRFS hdd layout this is a own partition with limited space. Also on BTRFS hdd layout the temp partition is an FAT format - so it can be easily mounted on Windows and OSx laptops by just connecting it to such laptops. Use this for easy export data. To import data make sure to work with the data before bootstrap is deleting the directory on startup." > ./README.txt
sudo mv ./README.txt /mnt/hdd/temp/README.txt 2>/dev/null
echo "The /mnt/hdd/app-data directory should be used by additional/optinal apps and services installed to the RaspiBlitz for their data that should survive an import/export/backup. Data that can be reproduced (indexes, etc.) should be stored in app-storage." > ./README.txt
sudo mv ./README.txt /mnt/hdd/app-data/README.txt 2>/dev/null
echo "The /mnt/hdd/app-storage directrory should be used by additional/optinal apps and services installed to the RaspiBlitz for their non-critical and reproducable data (indexes, public blockchain, etc.) that does not need to survive an an import/export/backup. Data is critical should be in app-data." > ./README.txt
sudo mv ./README.txt /mnt/hdd/app-storage/README.txt 2>/dev/null
>&2 echo "# OK - all symbolic links build"
exit 0
fi
########################################
# SWAP on data drive
########################################
if [ "$1" = "swap" ]; then
>&2 echo "# RASPIBLITZ DATA DRIVES - SWAP FILE"
if [ ${isMounted} -eq 0 ]; then
echo "error='no data drive mounted'"
exit 1
fi
if [ "$2" = "on" ]; then
if [ ${isSwapExternal} -eq 1 ]; then
>&2 echo "# OK - already ON"
exit 1
fi
>&2 echo "# Switch off/uninstall old SWAP"
sudo dphys-swapfile swapoff 1>/dev/null
sudo dphys-swapfile uninstall 1>/dev/null
if [ ${isBTRFS} -eq 1 ]; then
>&2 echo "# Rewrite external SWAP config for BTRFS setup"
sudo sed -i "12s/.*/CONF_SWAPFILE=\/mnt\/temp\/swapfile/" /etc/dphys-swapfile
sudo sed -i "16s/.*/#CONF_SWAPSIZE=/" /etc/dphys-swapfile
else
>&2 echo "# Rewrite external SWAP config for EXT4 setup"
sudo sed -i "12s/.*/CONF_SWAPFILE=\/mnt\/hdd\/swapfile/" /etc/dphys-swapfile
sudo sed -i "16s/.*/#CONF_SWAPSIZE=/" /etc/dphys-swapfile
fi
>&2 echo "# Creating SWAP file .."
sudo dd if=/dev/zero of=$externalSwapPath count=2048 bs=1MiB 1>/dev/null
sudo chmod 0600 $externalSwapPath 1>/dev/null
>&2 echo "# Activating new SWAP"
sudo mkswap $externalSwapPath
sudo dphys-swapfile setup
sudo dphys-swapfile swapon
>&2 echo "# OK - Swap is now ON external"
exit 0
elif [ "$2" = "off" ]; then
if [ ${isSwapExternal} -eq 0 ]; then
>&2 echo "# OK - already OFF"
exit 1
fi
>&2 echo "# Switch off/uninstall old SWAP"
sudo dphys-swapfile swapoff 1>/dev/null
sudo dphys-swapfile uninstall 1>/dev/null
>&2 echo "# Rewrite SWAP config"
sudo sed -i "12s/.*/CONF_SWAPFILE=\/var\/swap/" /etc/dphys-swapfile
sudo sed -i "16s/.*/#CONF_SWAPSIZE=/" /etc/dphys-swapfile
sudo dd if=/dev/zero of=/var/swap count=256 bs=1MiB 1>/dev/null
sudo chmod 0600 /var/swap
>&2 echo "# Create and switch on new SWAP"
sudo mkswap /var/swap 1>/dev/null
sudo dphys-swapfile setup 1>/dev/null
sudo dphys-swapfile swapon 1>/dev/null
>&2 echo "# OK - Swap is now OFF external"
exit 0
else
>&2 echo "# FAIL unkown second parameter - try 'on' or 'off'"
echo "error='unkown parameter'"
exit 1
fi
fi
########################################
# CLEAN data drives
########################################
if [ "$1" = "clean" ]; then
>&2 echo "# RASPIBLITZ DATA DRIVES - CLEANING"
if [ ${isMounted} -eq 0 ]; then
>&2 echo "# FAIL: cannot clean - the drive is not mounted'"
echo "error='not mounted'"
exit 1
fi
>&2 echo "# Making sure 'secure-delete' is installed ..."
sudo apt-get install -y secure-delete 1>/dev/null
>&2 echo
>&2 echo "# IMPORTANT: There is no 100% guarantee that sensitive data is completely deleted!"
>&2 echo "# see: https://www.davescomputers.com/securely-deleting-files-solid-state-drive/"
>&2 echo "# see: https://unix.stackexchange.com/questions/62345/securely-delete-files-on-btrfs-filesystem"
>&2 echo "# --> Dont resell or gift data drive. Destroy physically if needed."
>&2 echo
# DELETE ALL DATA (with option to keep blockchain)
if [ "$2" = "all" ]; then
if [ "$3" = "-total" ] || [ "$3" = "-keepblockchain" ]; then
>&2 echo "# Deleting personal Data .."
# make sure swap is off
sudo dphys-swapfile swapoff 1>/dev/null
sudo dphys-swapfile uninstall 1>/dev/null
sync
# for all other data shred files selectivly
for entry in $(ls -A1 /mnt/hdd)
do
delete=1
whenDeleteSchredd=1
# deactivate delete if a blockchain directory (if -keepblockchain)
if [ "$3" = "-keepblockchain" ]; then
if [ "${entry}" = "bitcoin" ] || [ "${entry}" = "litecoin" ]; then
delete=0
fi
fi
# decide when to shredd or just delete - just delete unsensitive data
if [ "${entry}" = "torrent" ] || [ "${entry}" = "app-storage" ]; then
whenDeleteSchredd=0
fi
if [ "${entry}" = "bitcoin" ] || [ "${entry}" = "litecoin" ]; then
whenDeleteSchredd=0
fi
# if BTRFS just shred stuff in /mnt/hdd/temp (because thats EXT4)
if [ ${isBTRFS} -eq 1 ] && [ "${entry}" != "temp" ]; then
whenDeleteSchredd=0
fi
# on SSDs never shredd
# https://www.davescomputers.com/securely-deleting-files-solid-state-drive/
if [ ${isSSD} -eq 1 ]; then
whenDeleteSchredd=0
fi
# delete or keep
if [ ${delete} -eq 1 ]; then
if [ -d "/mnt/hdd/$entry" ]; then
if [ ${whenDeleteSchredd} -eq 1 ]; then
>&2 echo "# shredding DIR : ${entry}"
sudo srm -r /mnt/hdd/$entry
else
>&2 echo "# deleting DIR : ${entry}"
sudo rm -r /mnt/hdd/$entry
fi
else
if [ ${whenDeleteSchredd} -eq 1 ]; then
>&2 echo "# shredding FILE : ${entry}"
sudo srm /mnt/hdd/$entry
else
>&2 echo "# deleting FILE : ${entry}"
sudo rm /mnt/hdd/$entry
fi
fi
else
>&2 echo "# keeping: ${entry}"
fi
done
# KEEP BLOCKCHAIN means just blocks & chainstate - delete the rest
if [ "$3" = "-keepblockchain" ]; then
chains=(bitcoin litecoin)
for chain in "${chains[@]}"
do
echo "Cleaning Blockchain: ${chain}"
# take extra care if wallet.db exists
sudo srm /mnt/hdd/${chain}/wallet.db 2>/dev/null
# the rest just delete (keep blocks and chainstate)
for entry in $(ls -A1 /mnt/hdd/${chain} 2>/dev/null)
do
# sorting file
delete=1
if [ "${entry}" = "blocks" ] || [ "${entry}" = "chainstate" ]; then
delete=0
fi
# delete or keep
if [ ${delete} -eq 1 ]; then
if [ -d "/mnt/hdd/${chain}/$entry" ]; then
>&2 echo "# Deleting DIR : /mnt/hdd/${chain}/${entry}"
sudo rm -r /mnt/hdd/${chain}/$entry
else
>&2 echo "# deleting FILE : /mnt/hdd/${chain}/${entry}"
sudo rm /mnt/hdd/${chain}/$entry
fi
else
>&2 echo "# keeping: ${entry}"
fi
done
done
fi
>&2 echo "# OK cleaning done."
exit 1
else
>&2 echo "# FAIL unkown third parameter try '-total' or '-keepblockchain'"
echo "error='unkown parameter'"
exit 1
fi
# RESET BLOCKCHAIN (e.g to rebuilt blockchain )
elif [ "$2" = "blockchain" ]; then
# here is no secure delete needed - because not sensitive data
>&2 echo "# Deleting all Blockchain Data (blocks/chainstate) from storage .."
# set path based on EXT4/BTRFS
basePath="/mnt/hdd"
if [ ${isBTRFS} -eq 1 ]; then
basePath="/mnt/storage"
fi
# deleting the blocks and chainstate
sudo rm -R ${basePath}/bitcoin/blocks 1>/dev/null 2>/dev/null
sudo rm -R ${basePath}/bitcoin/chainstate 1>/dev/null 2>/dev/null
sudo rm -R ${basePath}/litecoin/blocks 1>/dev/null 2>/dev/null
sudo rm -R ${basePath}/litecoin/chainstate 1>/dev/null 2>/dev/null
>&2 echo "# OK cleaning done."
exit 1
# RESET TEMP (keep swapfile)
elif [ "$2" = "temp" ]; then
>&2 echo "# Deleting the temp folder/drive (keeping SWAP file) .."
tempPath="/mnt/hdd/temp"
# better do secure delete, because temp is used for backups
# secure-delete works because - also in BTRFS setup, temp is EXT4
for entry in $(ls -A1 ${tempPath} 2>/dev/null)
do
# sorting file
delete=1
if [ "${entry}" = "swapfile" ]; then
delete=0
fi
# delete or keep
if [ ${delete} -eq 1 ]; then
if [ -d "${tempPath}/$entry" ]; then
>&2 echo "# shredding DIR : ${entry}"
sudo srm -r ${tempPath}/$entry
else
>&2 echo "# shredding FILE : ${entry}"
sudo srm ${tempPath}/$entry
fi
else
>&2 echo "# keeping: ${entry}"
fi
done
>&2 echo "# OK cleaning done."
exit 1
else
>&2 echo "# FAIL unkown second parameter - try 'all','blockchain' or 'temp'"
echo "error='unkown parameter'"
exit 1
fi
fi
echo "error='unkown command'"
exit 1
Reference in a new issue View git blame Copy permalink