mirrors/raspiblitz
1
0
Fork 0
mirror of https://github.com/rootzoll/raspiblitz.git synced 2025-02-25 07:07:46 +01:00
Code Issues Projects Releases Packages Wiki Activity
raspiblitz/home.admin/config.scripts/blitz.datadrive.sh
rootzoll 8f8353383b parted -a optimal for EXT4
2021-09-28 21:17:04 +02:00

1806 lines
60 KiB
Bash
Executable file
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|unmount|format|fstab|raid|link|swap|clean|snapshot|uasp-fix]"
echo "error='missing parameters'"
exit 1
fi
###################
# BASICS
###################
# TO UNDERSTAND THE BTFS HDD LAYOUT:
####################################
# 1) BLITZDATA - a BTRFS partition for all RaspiBlitz data - 30GB
# here put all files of LND, app, etc that need backup
# 2) BLITZSTORAGE - a BTFRS partition 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="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}"
# if HDD is not mounted system then it 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 partition)
# will then be used to offer formatting and permanent mounting
hdd=""
sizeDataPartition=0
OSPartition=$(sudo df /usr | grep dev | cut -d " " -f 1 | sed "s#/dev/##g")
# detect boot partition on UEFI systems
bootPartition=$(sudo df /boot/efi | grep dev | cut -d " " -f 1 | sed "s#/dev/##g")
if [ ${#bootPartition} -eq 0 ]; then
# for non UEFI
bootPartition=$(sudo df /boot | grep dev | cut -d " " -f 1 | sed "s#/dev/##g")
fi
lsblk -o NAME,SIZE -b | grep -P "[s|vn][dv][a-z][0-9]?" > .lsblk.tmp
while read line; do
# cut line info into different informations
testname=$(echo $line | cut -d " " -f 1 | sed 's/[^a-z0-9]*//g')
testdevice=$(echo $testname | sed 's/[^a-z]*//g')
testpartition=$(echo $testname | grep -P '[a-z]{3,5}[0-9]{1}')
if [ ${#testpartition} -gt 0 ]; then
testsize=$(echo $line | sed "s/ */ /g" | cut -d " " -f 2 | sed 's/[^0-9]*//g')
else
testsize=0
fi
#echo "# line($line)"
#echo "# testname(${testname}) testdevice(${testdevice}) testpartition(${testpartition}) testsize(${testsize})"
# count partitions
testpartitioncount=0
if [ ${#testdevice} -gt 0 ]; then
testpartitioncount=$(sudo fdisk -l | grep /dev/$testdevice | wc -l)
# do not count line with disk info
testpartitioncount=$((testpartitioncount-1))
fi
#echo "# testpartitioncount($testpartitioncount)"
#echo "# testpartitioncount(${testpartitioncount})"
#echo "# OSPartition(${OSPartition})"
#echo "# bootPartition(${bootPartition})"
#echo "# hdd(${hdd})"
if [ $testpartitioncount -gt 0 ]; then
# if a partition was found - make sure to skip the OS and boot partitions
if [ "$testpartition" != "$OSPartition" ] && [ "$testpartition" != "$bootPartition" ]; then
# make sure to use the biggest
if [ ${testsize} -gt ${sizeDataPartition} ]; then
sizeDataPartition=${testsize}
hddDataPartition="${testpartition}"
hdd="${testdevice}"
fi
fi
else
# default hdd set, when there is no OSpartition and there might be no partitions at all
if [ "${OSPartition}" = "root" ] && [ "${hdd}" = "" ] && [ "${testdevice}" != "" ]; then
hdd="${testdevice}"
fi
# make sure to use the biggest
if [ ${testsize} -gt ${sizeDataPartition} ]; then
# Partition to be created is smaller than disk so this is not correct (but close)
sizeDataPartition=$(sudo fdisk -l /dev/$testdevice | grep GiB | cut -d " " -f 5)
hddDataPartition="${testdevice}1"
hdd="${testdevice}"
fi
fi
done < .lsblk.tmp
rm -f .lsblk.tmp 1>/dev/null 2>/dev/null
# display possible warnings from hdd partition detection
if [ "${hddPartitionCandidate}" != "" ] && [ ${#hddDataPartition} -lt 4 ]; then
echo "# WARNING: found invalid partition (${hddDataPartition}) - redacting"
hddDataPartition=""
fi
# try to detect if its an SSD
isSSD=$(sudo cat /sys/block/${hdd}/queue/rotational 2>/dev/null | grep -c 0)
echo "isSSD=${isSSD}"
# display results from hdd & partition detection
echo "hddCandidate='${hdd}'"
hddBytes=0
hddGigaBytes=0
if [ "${hdd}" != "" ]; then
hddBytes=$(sudo fdisk -l /dev/$hdd | grep GiB | cut -d " " -f 5)
hddGigaBytes=$(echo "scale=0; ${hddBytes}/1024/1024/1024" | bc -l)
fi
echo "hddBytes=${hddBytes}"
echo "hddGigaBytes=${hddGigaBytes}"
echo "hddPartitionCandidate='${hddDataPartition}'"
# if positive deliver more data
if [ ${#hddDataPartition} -gt 0 ]; then
# check partition size in bytes and GBs
echo "hddDataPartitionBytes=${sizeDataPartition}"
hddDataPartitionGigaBytes=$(echo "scale=0; ${sizeDataPartition}/1024/1024/1024" | bc -l)
echo "hddPartitionGigaBytes=${hddDataPartitionGigaBytes}"
# check format of devices partition
hddFormat=$(lsblk -o FSTYPE,NAME,TYPE | grep part | grep "${hddDataPartition}" | 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 subvolumes 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
hddDataPartitionExt4=$hddDataPartition
mountError=$(sudo mount /dev/${hddDataPartitionExt4} /mnt/hdd 2>&1)
isTempMounted=$(df | grep /mnt/hdd | grep -c ${hddDataPartitionExt4})
fi
if [ "${hddFormat}" = "btrfs" ]; then
mountError=$(sudo mount -o degraded /dev/${hdd}1 /mnt/hdd 2>&1)
isTempMounted=$(df | grep /mnt/hdd | grep -c ${hdd})
fi
# check for mount error
if [ ${#mountError} -gt 0 ] || [ ${isTempMounted} -eq 0 ]; then
echo "hddError='data mount failed'"
else
#####################################
# Pre-Setup Investigation of DATA-PART
# check for recoverable RaspiBlitz data (if config file exists) and raid
hddRaspiData=$(sudo ls -l /mnt/hdd${subVolumeDir} 2>/dev/null | grep -c raspiblitz.conf)
#isRaid=$(btrfs filesystem df /mnt/hdd 2>/dev/null | grep -c "Data, RAID1")
echo "hddRaspiData=${hddRaspiData}"
hddRaspiVersion=""
if [ ${hddRaspiData} -eq 1 ]; then
source /mnt/hdd${subVolumeDir}/raspiblitz.conf
hddRaspiVersion="${raspiBlitzVersion}"
fi
echo "hddRaspiVersion='${hddRaspiVersion}'"
# check if there is a wifi configuration as backup
hddGotWifiConf=$(ls /mnt/hdd${subVolumeDir}/app-data/wpa_supplicant.conf 2>/dev/null | grep -c "wpa_supplicant.conf")
if [ ${hddGotWifiConf} -eq 1 ]; then
# make a copy to the mem cache drive (so that Wifi can be connected before setup & final HDD mount)
sudo cp /mnt/hdd${subVolumeDir}/app-data/wpa_supplicant.conf /var/cache/raspiblitz/wpa_supplicant.conf
echo "wifiBackupConfigCopy='/var/cache/raspiblitz/wpa_supplicant.conf'"
fi
# comment this line out if case to study the contect of the data section
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
isTempMounted=$(df | grep /mnt/storage | grep -c ${hdd})
else
# in ext4 setup the partition is also the storage partition
sudo mount /dev/${hddDataPartitionExt4} /mnt/storage 2>/dev/null
isTempMounted=$(df | grep /mnt/storage | grep -c ${hddDataPartitionExt4})
fi
if [ ${isTempMounted} -eq 0 ]; then
echo "hddError='storage mount failed'"
else
########################################
# Pre-Setup Invetigation of STORAGE-PART
# 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}"
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 free space on data drive
if [ ${isBTRFS} -eq 0 ]; then
# EXT4
hdd_data_free1Kblocks=$(df -h -k /dev/${hddDataPartitionExt4} | grep "/dev/${hddDataPartitionExt4}" | sed -e's/ */ /g' | cut -d" " -f 4 | tr -dc '0-9')
else
# BRTS
hdd_data_free1Kblocks=$(df -h -k /dev/${hdd}1 | grep "/dev/${hdd}1" | sed -e's/ */ /g' | cut -d" " -f 4 | tr -dc '0-9')
fi
echo "hddDataFreeKB=${hdd_data_free1Kblocks}"
# check if its another fullnode implementation data disk
hddGotMigrationData=""
if [ "${hddFormat}" = "ext4" ]; then
# check for umbrel
isUmbrelHDD=$(sudo ls /mnt/storage/umbrel/info.json 2>/dev/null | grep -c '.json')
if [ ${isUmbrelHDD} -gt 0 ]; then
hddGotMigrationData="umbrel"
fi
isMyNodeHDD=$(sudo ls /mnt/storage/mynode/bitcoin/bitcoin.conf 2>/dev/null | grep -c '.conf')
if [ ${isMyNodeHDD} -gt 0 ]; then
hddGotMigrationData="mynode"
fi
else
echo "# not an ext4 drive - all known fullnode packages use ext4 at the moment"
fi
echo "hddGotMigrationData='${hddGotMigrationData}'"
# comment this line out if case to study the contect of the storage section
sudo umount /mnt/storage
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
if [ ${isBTRFS} -eq 1 ]; then
# on btrfs date the storage partition as the data partition
hddDataPartition=$(df | grep "/mnt/storage$" | cut -d " " -f 1 | cut -d "/" -f 3)
else
# on ext4 its the whole /mnt/hdd
hddDataPartition=$(df | grep "/mnt/hdd$" | cut -d " " -f 1 | cut -d "/" -f 3)
fi
hdd=$(echo $hddDataPartition | sed 's/[0-9]*//g')
hddFormat=$(lsblk -o FSTYPE,NAME,TYPE | grep part | grep "${hddDataPartition}" | cut -d " " -f 1)
if [ "${hddFormat}" = "ext4" ]; then
hddDataPartitionExt4=$hddDataPartition
fi
hddRaspiData=$(sudo ls -l /mnt/hdd | grep -c raspiblitz.conf)
echo "hddRaspiData=${hddRaspiData}"
hddRaspiVersion=""
if [ ${hddRaspiData} -eq 1 ]; then
source /mnt/hdd/raspiblitz.conf
hddRaspiVersion="${raspiBlitzVersion}"
fi
echo "hddRaspiVersion='${hddRaspiVersion}'"
isSSD=$(sudo cat /sys/block/${hdd}/queue/rotational 2>/dev/null | grep -c 0)
echo "isSSD=${isSSD}"
echo "datadisk='${hdd}'"
echo "datapartition='${hddDataPartition}'"
# 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
sizeDataPartition=$(lsblk -o NAME,SIZE -b | grep "${hddDataPartition}" | awk '$1=$1' | cut -d " " -f 2)
echo "hddBytes=${sizeDataPartition}"
hddGigaBytes=$(echo "scale=0; ${sizeDataPartition}/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/${hddDataPartitionExt4}" | sed -e's/ */ /g' | cut -d" " -f 3 2>/dev/null)
hdd_used_ratio=$(df -h | grep "/dev/${hddDataPartitionExt4}" | sed -e's/ */ /g' | cut -d" " -f 5 | tr -dc '0-9' 2>/dev/null)
hdd_data_free1Kblocks=$(df -h -k /dev/${hddDataPartitionExt4} | grep "/dev/${hddDataPartitionExt4}" | sed -e's/ */ /g' | cut -d" " -f 4 | tr -dc '0-9')
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)
hdd_data_free1Kblocks=$(df -h -k /dev/${hdd}1 | grep "/dev/${hdd}1" | sed -e's/ */ /g' | cut -d" " -f 4 | tr -dc '0-9')
hddUsedInfo="${datadrive} & ${storageDrive}"
fi
echo "hddUsedInfo='${hddUsedInfo}'"
echo "hddDataFreeKB=${hdd_data_free1Kblocks}"
fi
# HDD Adpater UASP support --> https://www.pragmaticlinux.com/2021/03/fix-for-getting-your-ssd-working-via-usb-3-on-your-raspberry-pi/
# in both cases (if mounted or not - using the hdd selection from both cases)
if [ ${#hdd} -gt 0 ]; then
# determine USB HDD adapter model ID
hddAdapter=$(lsusb | grep "SATA" | head -1 | cut -d " " -f6)
if [ "${hddAdapter}" == "" ]; then
hddAdapter=$(lsusb | grep "GC Protronics" | head -1 | cut -d " " -f6)
fi
if [ "${hddAdapter}" == "" ]; then
hddAdapter=$(lsusb | grep "ASMedia Technology" | head -1 | cut -d " " -f6)
fi
echo "hddAdapterUSB='${hddAdapter}'"
hddAdapterUSAP=0
# check if user wants to force UASP on
if [ -f "/boot/uasp.force" ]; then
hddAdapterUSAP=1
echo "uaspForced=1"
fi
if [ $(cat /mnt/hdd/raspiblitz.conf 2>/dev/null | grep -c "forceUasp=on") -eq 1 ]; then
hddAdapterUSAP=1
fi
# check if HDD ADAPTER is on UASP WHITELIST (tested devices)
if [ "${hddAdapter}" == "174c:55aa" ]; then
# UGREEN 2.5" External USB 3.0 Hard Disk Case with UASP support
hddAdapterUSAP=1
fi
if [ "${hddAdapter}" == "0825:0001" ] || [ "${hddAdapter}" == "174c:0825" ]; then
# SupTronics 2.5" SATA HDD Shield X825 v1.5
hddAdapterUSAP=1
fi
echo "hddAdapterUSAP=${hddAdapterUSAP}"
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 candidate (hdd/ssd)
if [ ${devMounted} -eq 0 ] && [ "${disk}" != "${hdd}" ] && [ "${hdd}" != "" ] && [ "${disk}" != "" ]; 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 | sed 's/[^a-zA-Z0-9]//g')
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 formatting
if [ "$1" = "format" ]; then
# check valid format
if [ "$2" = "btrfs" ]; then
>&2 echo "# DATA DRIVE - FORMATTING to BTRFS layout (new)"
elif [ "$2" = "ext4" ]; then
>&2 echo "# DATA DRIVE - FORMATTING to 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 candidate devices"
echo "error='missing parameter'"
exit 1
fi
if [ "$2" = "btrfs" ]; then
# check if device is existing and a disk (not a partition)
isValid=$(lsblk -o NAME,TYPE | grep disk | grep -c "${hdd}")
else
# check if device is existing (its OK when its a partition)
isValid=$(lsblk -o NAME,TYPE | grep -c "${hdd}")
fi
if [ ${isValid} -eq 0 ]; then
>&2 echo "# 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 drive
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 UUID,NAME | grep "${hdd}" | cut -d " " -f 1 | grep "-" | while read -r uuid ; do
if [ ${#uuid} -gt 0 ]; then
>&2 echo "# Cleaning /etc/fstab from ${uuid}"
sudo sed -i "/UUID=${uuid}/d" /etc/fstab
sync
else
>&2 echo "# skipping empty result"
fi
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
>&2 echo "# ERROR: failed to unmount /mnt/hdd"
echo "error='failed to unmount /mnt/hdd'"
exit 1
fi
unmounted2=$(df | grep -c "/mnt/temp")
if [ ${unmounted2} -gt 0 ]; then
>&2 echo "# ERROR: failed to unmount /mnt/temp"
echo "error='failed to unmount /mnt/temp'"
exit 1
fi
unmounted3=$(df | grep -c "/mnt/storage")
if [ ${unmounted3} -gt 0 ]; then
>&2 echo "# ERROR: failed to unmount /mnt/storage"
echo "error='failed to unmount /mnt/storage'"
exit 1
fi
fi
if [[ $hdd =~ [0-9] ]]; then
ext4IsPartition=1
else
ext4IsPartition=0
fi
wipePartitions=0
if [ "$2" = "btrfs" ]; then
wipePartitions=1
fi
if [ "$2" = "ext4" ] && [ $ext4IsPartition -eq 0 ]; then
wipePartitions=1
fi
if [ $wipePartitions -eq 1 ]; then
# wipe all partitions and write fresh GPT
>&2 echo "# Wiping all partitions (sfdisk/wipefs)"
sudo sfdisk --delete /dev/${hdd}
sleep 4
sudo wipefs -a /dev/${hdd}
sleep 4
partitions=$(lsblk | grep -c "─${hdd}")
if [ ${partitions} -gt 0 ]; then
>&2 echo "# WARNING: partitions are still not clean - try Quick & Dirty"
sudo dd if=/dev/zero of=/dev/${hdd} bs=512 count=1
fi
partitions=$(lsblk | grep -c "─${hdd}")
if [ ${partitions} -gt 0 ]; then
>&2 echo "# ERROR: partition cleaning failed"
echo "error='partition cleaning failed'"
exit 1
fi
sudo parted -s -a optimal -- /dev/${hdd} mklabel gpt 1>/dev/null 1>&2
sleep 2
sync
fi
# formatting old: EXT4
if [ "$2" = "ext4" ]; then
# prepare temp mount point
sudo mkdir -p /tmp/ext4 1>/dev/null
if [ $ext4IsPartition -eq 0 ]; then
# write new EXT4 partition
>&2 echo "# Creating the one big partition"
sudo parted /dev/${hdd} mkpart primary ext4 0% 100% 1>&2
sleep 6
sync
# loop until the partition gets available
loopdone=0
loopcount=0
while [ ${loopdone} -eq 0 ]
do
>&2 echo "# waiting until the partition gets available"
sleep 2
sync
loopdone=$(lsblk -o NAME | grep -c ${hdd}1)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 10 ]; then
>&2 echo "# partition failed"
echo "error='partition failed'"
exit 1
fi
done
>&2 echo "# partition available"
fi
# 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
>&2 echo "# ERROR: failed to unmount /tmp/ext4"
echo "error='failed to unmount /tmp/ext4'"
exit 1
fi
>&2 echo "# Formatting"
if [ $ext4IsPartition -eq 0 ]; then
sudo mkfs.ext4 -F -L BLOCKCHAIN /dev/${hdd}1 1>/dev/null
else
sudo mkfs.ext4 -F -L BLOCKCHAIN /dev/${hdd} 1>/dev/null
fi
loopdone=0
loopcount=0
while [ ${loopdone} -eq 0 ]
do
>&2 echo "# waiting until formatted drives gets available"
sleep 2
sync
loopdone=$(lsblk -o NAME,LABEL | grep -c BLOCKCHAIN)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 10 ]; then
>&2 echo "# ERROR: formatting ext4 failed"
echo "error='formatting ext4 failed'"
exit 1
fi
done
# setting fsk check interval to 1
# see https://github.com/rootzoll/raspiblitz/issues/360#issuecomment-467567572
if [ $ext4IsPartition -eq 0 ]; then
sudo tune2fs -c 1 /dev/${hdd}1
else
sudo tune2fs -c 1 /dev/${hdd}
fi
>&2 echo "# OK EXT 4 format done"
exit 0
fi
# formatting new: BTRFS layout - this consists of 3 volumes:
if [ "$2" = "btrfs" ]; then
# prepare temp mount point
sudo mkdir -p /tmp/btrfs 1>/dev/null
>&2 echo "# Creating BLITZDATA (${hdd})"
sudo parted -s -a optimal -- /dev/${hdd} mkpart primary btrfs 0% 30GiB 1>/dev/null
sync
sleep 6
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
# check result
loopdone=0
loopcount=0
while [ ${loopdone} -eq 0 ]
do
>&2 echo "# waiting until formatted drives gets available"
sleep 2
sync
sudo parted -l
loopdone=$(lsblk -o NAME,LABEL | grep -c BLITZDATA)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 60 ]; then
>&2 echo "# ERROR: formatting BTRFS failed (BLITZDATA)"
>&2 echo "# check with: lsblk -o NAME,LABEL | grep -c BLITZDATA"
echo "error='formatting failed'"
exit 1
fi
done
>&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 6
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
# check result
loopdone=0
loopcount=0
while [ ${loopdone} -eq 0 ]
do
>&2 echo "# waiting until formatted drives gets available"
sleep 2
sync
sudo parted -l
loopdone=$(lsblk -o NAME,LABEL | grep -c BLITZSTORAGE)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 60 ]; then
>&2 echo "# ERROR: formatting BTRFS failed (BLITZSTORAGE)"
echo "error='formatting failed'"
exit 1
fi
done
>&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 partition"
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
# check result
loopdone=0
loopcount=0
while [ ${loopdone} -eq 0 ]
do
>&2 echo "# waiting until formatted drives gets available"
sleep 2
sync
sudo parted -l
loopdone=$(lsblk -o NAME,LABEL | grep -c BLITZTEMP)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 60 ]; then
>&2 echo "# ERROR: formatting vfat failed (BLITZTEMP)"
echo "error='formatting failed'"
exit 1
fi
done
>&2 echo "# OK BLITZTEMP exists now"
>&2 echo "# OK BTRFS format done"
exit 0
fi
fi
########################################
# Refresh FSTAB for permanent mount
########################################
if [ "$1" = "fstab" ]; then
# get device to temp mount
hdd=$2
if [ ${#hdd} -eq 0 ]; then
echo "# FAIL which device/partition should be temp mounted (e.g. sda)"
echo "# run 'status' to see device candidates"
echo "error='missing second parameter'"
exit 1
fi
# check if exist and which format
# if hdd is a partition (ext4)
if [[ $hdd =~ [0-9] ]]; then
# ext4
hddFormat=$(lsblk -o FSTYPE,NAME | grep ${hdd} | cut -d ' ' -f 1)
else
# btrfs
hddFormat=$(lsblk -o FSTYPE,NAME | grep ${hdd}1 | cut -d ' ' -f 1)
fi
if [ ${#hddFormat} -eq 0 ]; then
echo "# FAIL given device/partition not found"
echo "error='device not found'"
exit 1
fi
# unmount
if [ ${isMounted} -eq 1 ]; then
echo "# unmounting all drives"
sudo umount /mnt/hdd > /dev/null 2>&1
sudo umount /mnt/storage > /dev/null 2>&1
sudo umount /mnt/temp > /dev/null 2>&1
fi
if [ "${hddFormat}" = "ext4" ]; then
### EXT4 ###
hddDataPartitionExt4=$hdd
# loop until the uuids are available
uuid1=""
loopcount=0
while [ ${#uuid1} -eq 0 ]
do
echo "# waiting until uuid gets available"
sleep 2
sync
uuid1=$(lsblk -o NAME,UUID | grep "${hddDataPartitionExt4}" | 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
echo "# mount /mnt/hdd"
sudo mkdir -p /mnt/hdd 1>/dev/null
updated=$(cat /etc/fstab | grep -c "/mnt/hdd")
if [ $updated -eq 0 ]; then
echo "# updating /etc/fstab"
sudo sed "/raspiblitz/ i UUID=${uuid1} /mnt/hdd ext4 noexec,defaults 0 2" -i /etc/fstab 1>/dev/null
fi
sync
sudo mount -a 1>/dev/null
# loop mounts are available
mountactive1=0
loopcount=0
while [ ${mountactive1} -eq 0 ]
do
echo "# waiting until mounting is active"
sleep 2
sync
mountactive1=$(df | grep -c /mnt/hdd)
loopcount=$(($loopcount +1))
if [ ${loopcount} -gt 10 ]; then
echo "# WARNING was not able freshly mount new devices - might need reboot or check /etc/fstab"
echo "needsReboot=1"
exit 0
fi
done
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 UUID,NAME | grep "${hdd}" | cut -d " " -f 1 | 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 groupid 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 devices - 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='unknown 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 partitions 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 big
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 than the minimum 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
# get HDD status and candidates
source <(/home/admin/config.scripts/blitz.datadrive.sh status)
if [ ${isMounted} -eq 1 ]; then
echo "error='already mounted'"
exit 1
fi
# get device to temp mount from parameter (optional)
hdd=$2
# automount if no parameter the hddcandinate
if [ "${hdd}" == "" ]; then
if [ "${hddFormat}" != "btrfs" ]; then
hdd="${hddPartitionCandidate}"
else
hdd="${hddCandidate}"
fi
fi
# if still no hdd .. throw error
if [ "${hdd}" == "" ]; then
>&2 echo "# FAIL there is no detected hdd candidate to tempmount"
echo "error='hdd not found'"
exit 1
fi
# if hdd is a partition
if [[ $hdd =~ [0-9] ]]; then
hddDataPartition=$hdd
hddDataPartitionExt4=$hddDataPartition
hddFormat=$(lsblk -o FSTYPE,NAME | grep ${hddDataPartitionExt4} | cut -d ' ' -f 1)
else
hddBTRFS=$hdd
hddFormat=$(lsblk -o FSTYPE,NAME | grep ${hddBTRFS}1 | cut -d ' ' -f 1)
fi
if [ ${#hddFormat} -eq 0 ]; then
>&2 echo "# FAIL given device not found"
echo "error='device not found'"
exit 1
fi
if [ "${hddFormat}" = "ext4" ]; then
if [ "${hddDataPartitionExt4}" == "" ]; then
echo "error='parameter is no partition'"
exit 1
fi
# do EXT4 temp mount
echo "# temp mount /dev/${hddDataPartitionExt4} --> /mnt/hdd"
sudo mkdir -p /mnt/hdd 1>/dev/null
sudo mount /dev/${hddDataPartitionExt4} /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 groupid 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/${hddBTRFS}1 /mnt/hdd
sudo mount -t btrfs -o subvol=WORKINGDIR /dev/${hddBTRFS}2 /mnt/storage
sudo mount -o umask=0000,uid=${bitcoinUID},gid=${bitcoinGID} /dev/${hddBTRFS}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
if [ "$1" = "unmount" ]; then
sudo umount /mnt/hdd 2>/dev/null
sudo umount /mnt/storage 2>/dev/null
sudo umount /mnt/temp 2>/dev/null
echo "# OK done unmount"
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 -F /mnt/hdd/bitcoin | grep -c '/mnt/hdd/bitcoin@') -eq 0 ]; then
sudo mkdir -p /mnt/storage/bitcoin
sudo cp -R /mnt/hdd/bitcoin/* /mnt/storage/bitcoin 2>/dev/null
sudo chown -R bitcoin:bitcoin /mnt/storage/bitcoin
sudo rm -r /mnt/hdd/bitcoin
sudo ln -s /mnt/storage/bitcoin /mnt/hdd/bitcoin
sudo rm /mnt/storage/bitcoin/bitcoin 2>/dev/null
fi
if [ $(ls -F /mnt/hdd/litecoin | grep -c '/mnt/hdd/litecoin@') -eq 0 ]; then
sudo mkdir -p /mnt/storage/litecoin
sudo cp -R /mnt/hdd/litecoin/* /mnt/storage/litecoin 2>/dev/null
sudo chown -R bitcoin:bitcoin /mnt/storage/litecoin
sudo rm -r /mnt/hdd/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 777 /mnt/temp
sudo chmod -R 777 /mnt/hdd/temp
sudo chmod 777 /mnt
# 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/optional 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 directory should be used by additional/optional apps and services installed to the RaspiBlitz for their non-critical and reproducible 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 unknown second parameter - try 'on' or 'off'"
echo "error='unknown parameter'"
exit 1
fi
fi
########################################
# CLEAN data drives
########################################
if [ "$1" = "clean" ]; then
>&2 echo "# RASPIBLITZ DATA DRIVES - CLEANING"
# get HDD status
source <(/home/admin/config.scripts/blitz.datadrive.sh status)
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: No 100% guarantee that sensitive data is completely deleted!"
# see: https://www.davescomputers.com/securely-deleting-files-solid-state-drive/"
# 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 selectively
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 shred or just delete - just delete nonsensitive 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 shred
# https://www.davescomputers.com/securely-deleting-files-solid-state-drive/
if [ "${isSSD}" == "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 -lr /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 -l /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 -v /mnt/hdd/${chain}/wallet.db 2>/dev/null
# the rest just delete (keep blocks and chainstate and testnet3)
for entry in $(ls -A1 /mnt/hdd/${chain} 2>/dev/null)
do
# sorting file
delete=1
if [ "${entry}" = "blocks" ] || [ "${entry}" = "chainstate" ]\
|| [ "${entry}" = "testnet3" ] ; 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
# keep blocks and chainstate in testnet3 if exists
if [ -d /mnt/hdd/bitcoin/testnet3 ];then
for entry in $(ls -A1 /mnt/hdd/bitcoin/testnet3 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/bitcoin/testnet3/$entry" ]; then
>&2 echo "# Deleting DIR : /mnt/hdd/bitcoin/testnet3/${entry}"
sudo rm -r /mnt/hdd/bitcoin/testnet3/$entry
else
>&2 echo "# deleting FILE : /mnt/hdd/bitcoin/testnet3/${entry}"
sudo rm /mnt/hdd/bitcoin/testnet3/$entry
fi
else
>&2 echo "# keeping: ${entry}"
fi
done
fi
done
fi
>&2 echo "# OK cleaning done."
exit 1
else
>&2 echo "# FAIL unknown third parameter try '-total' or '-keepblockchain'"
echo "error='unknown 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"
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 rm -r ${tempPath}/$entry
else
>&2 echo "# shredding FILE : ${entry}"
sudo rm ${tempPath}/$entry
fi
else
>&2 echo "# keeping: ${entry}"
fi
done
>&2 echo "# OK cleaning done."
exit 1
else
>&2 echo "# FAIL unknown second parameter - try 'all','blockchain' or 'temp'"
echo "error='unknown parameter'"
exit 1
fi
fi
########################################
# UASP-fix
########################################
if [ "$1" = "uasp-fix" ]; then
# get HDD status and if the connected adapter is supports UASP
source <(/home/admin/config.scripts/blitz.datadrive.sh status)
# check if UASP is already deactivated (on RaspiOS)
# https://www.pragmaticlinux.com/2021/03/fix-for-getting-your-ssd-working-via-usb-3-on-your-raspberry-pi/
cmdlineExists=$(sudo ls /boot/cmdline.txt 2>/dev/null | grep -c "cmdline.txt")
if [ ${cmdlineExists} -eq 1 ] && [ ${#hddAdapterUSB} -gt 0 ] && [ ${hddAdapterUSAP} -eq 0 ]; then
echo "# Checking for UASP deactivation ..."
usbQuirkActive=$(sudo cat /boot/cmdline.txt | grep -c "usb-storage.quirks=")
usbQuirkDone=$(sudo cat /boot/cmdline.txt | grep -c "usb-storage.quirks=${hddAdapterUSB}:u")
if [ ${usbQuirkActive} -gt 0 ] && [ ${usbQuirkDone} -eq 0 ]; then
# remove old usb-storage.quirks
sudo sed -i "s/usb-storage.quirks=[^ ]* //g" /boot/cmdline.txt
fi
if [ ${usbQuirkDone} -eq 0 ]; then
# add new usb-storage.quirks
sudo sed -i "1s/^/usb-storage.quirks=${hddAdapterUSB}:u /" /boot/cmdline.txt
# go into reboot to activate new setting
echo "# DONE deactivating UASP for ${hddAdapterUSB} ... reboot needed"
echo "neededReboot=1"
else
echo "# Already UASP deactivated for ${hddAdapterUSB}"
echo "neededReboot=0"
fi
else
echo "# Skipping UASP deactivation ... cmdlineExists(${cmdlineExists}) hddAdapterUSB(${hddAdapterUSB}) hddAdapterUSAP(${hddAdapterUSAP})"
echo "neededReboot=0"
fi
exit 0
fi
echo "error='unkown command'"
exit 1
Reference in a new issue View git blame Copy permalink