Script para backup de banco de dados FirebirdSQL

#!/bin/bash
# Script desenvolvido por :
# Hamacker <sirhamacker [em] gmail.com>
# Data : 02/02/2006
# Uso : Faz backup de servidores firebird em discos ou pendrives externos.

# trap ctrl-c and call ctrl_c() trap ctrl_c INT
trap ctrl_c INT
function ctrl_c() {
  echo "*** backup interrompido pelo usuario ***" ;
  do_sendmail;
  exit 1;
}

function log() {
  if [ -z "$1" ] ; then
    echo "Parametro para log esta vazio"
    return
  fi
  if ! [ -f "$file_error_log" ] ; then
    echo "Arquivo para registrar log [$file_error_log]  não existe !"
    echo -ne "Criando um arquivo vazio..."
    touch "$file_error_log"
    echo "[OK]"
  fi
  echo "$1"
  echo "$1" >>$file_error_log
}

function do_montar_dev() {
  alvo_device="$1"
  alvo_pasta="$2"
  RESULT_VALUE="FALHOU"
  if [ "$alvo_device" = "" ] ; then
     log "Erro na montagem de dispositivo : O nome do dispositivo não foi informado."
     return
  fi
  if [ "$alvo_pasta" = "" ] ; then
     log "Erro na montagem de dispositivo : O nome do pasta onde seria montado o dispositivo não foi informado."
     return
  fi
  if ! [ -d  "$alvo_pasta" ] ; then
    mkdir -p "$alvo_pasta"
  fi
  # montando a unidade de destino, normalmente o usbdisk
  mount -t $ponto_fs $alvo_device $alvo_pasta -o sync,nosuid,nouser,rw,dirsync,users
  if [ $? -ne 0 ] ; then
    log "A montagem da unidade de destino-backup falhou !"
    log "Tentativa : mount -t $ponto_fs $ponto_device $ponto_destino -o sync,nosuid,nouser,rw,dirsync,users"
    log "Certifique-se que :"
    log "- tenha ligado a unidade numa porta USB deste servidor;"
    log "- o dispositivo USB esteja ligado com o led de funcionamento piscando."
    log "Desligue o aparelho, aguarde alguns instantes e ligue-o novamente"
    log "e repita a operacao, se insistir o problema contate"
    log "imediatamente o supervidor."
  else
    RESULT_VALUE="OK"
  fi
}

function do_desmontar() {
  alvo="$1"
  if [ "$alvo" = "" ] || \
     ! [ -d "$alvo" ] ; then
     echo "alvo para desmontar nao existe : [$alvo]"
     return
  fi
  # so posso desmontar unidades em /mnt ou /media
  dir_to_unmount=$(mount |grep "$alvo"|cut -d" " -f 3|cut -d"/" -f 2)
  if [ "$dir_to_unmount" != "media" ] && [ "$dir_to_unmount" != "mnt" ] ; then
    return
  fi

  # verifica se esta realmente montado
  EXISTE=`mount |grep $alvo|wc -l`
  if [ "$EXISTE" -gt 0 ] ; then
    umount $alvo
    [ -d "$alvo" ] && rmdir $alvo
  fi

  # se o diretorio montado estiver vazio e estiver localizado em /mnt entao remove-lo
  if ! [[ "$alvo" =~ "/media" ]] ; then
    if [ -d "$alvo" ] && [ "$dir_to_unmount" = "mnt" ] ; then
      if [ "$alvo/*" = "$alvo/*" ] ; then
        echo "removendo diretorio vazio [$alvo]"
        rmdir $alvo
      fi
    fi
  fi
}

function do_backup_firebirdsql() {
  log "****************************************************"
  log "* BACKUP DO SERVIDOR DE BANCO DE DADOS FIREBIRDSQL *"
  log "****************************************************"
  # montando a unidade de destino, normalmente o usbdisk
  do_montar_dev "$ponto_device" "$ponto_destino"
  if [ "$RESULT_VALUE" != "OK" ] ; then
    do_sendmail;
    return;
  fi
  # lista de databases do firebird a serem backupeados
  # coloque os databases em ordem de importancia
  # lista de pastas a serem backupeadas
  unset backup_lista
  backup_lista=( "${backup_lista[@]}" "192.168.1.14:admin1.fdb" )
  #backup_lista=( "${backup_lista[@]}" "192.168.1.14:security2.fdb" )
  #backup_lista=( "${backup_lista[@]}" "192.168.1.14:c:/Arquivos de programas/Firebird/Firebird_2_1/security2.fdb" )
  #backup_lista=( "${backup_lista[@]}" "192.168.1.14:/var/lib/firebird2/system/security.fdb" )

  for fb_source in "${backup_lista[@]}" ; do
    # o nome do arquivo de backup sera praticamente o mesmo
    # nome da origem, apenas o sufixo .fbk para diferenciar
    # e os _ que subsituirao caracteres especiais
    fb_dest="$fb_source"
    fb_dest=${fb_dest//.fb/\.fbk}
    fb_dest=${fb_dest//.fdb/\.fbk}
    fb_dest=${fb_dest//.dat/\.fbk}
    fb_dest=${fb_dest//.gdb/\.fbk}
    # trocando / por _
    fb_dest=${fb_dest//\//\_}
    # trocando : por apenas -
    fb_dest=${fb_dest//:/\-}
    # trocando \\ por apenas -
    fb_dest=${fb_dest//\\/\-}
    # trocando -_ por apenas -
    fb_dest=${fb_dest//-_/\-}
    # acrescentando o path de destino
    fb_dest="$backup_folder/firebird/$fb_dest"
    fb_folder=`dirname "$fb_dest"`
    if ! [ -d "$fb_folder" ] ; then
      mkdir -p "$fb_folder"
    fi
    log "Processando backup de  \"$fb_source\" para \"$fb_dest\""
    $GBAK -t -user "$FB_USER" -password "$FB_PASSWORD" "$fb_source" "$fb_dest" 2>>$file_error_log
    if [ $? -ne 0 ] ; then
      log "[backup-falhou] firebird : $GBAK -v -t -user \"$FB_USER\" -password \"*****\" \"$fb_source\" \"$fb_dest\""
      DO_BACKUP_STATUS_FIREBIRDSQL="N"
    else
      log "[sucesso] firebird : backup de \"$fb_source\" para \"$fb_dest\""
    fi
  done

  ### desmontando a unidade de destino
  do_desmontar "$ponto_destino"
}

############################
# Inicio do Programa       #
############################

export LANGUAGE="pt_BR:pt:pt_PT"
export LANG="pt_BR.UTF-8"

if [ "$USER" != "root" ] ; then
  echo  "Infelizmente este programa só pode ser executado com o usuario root ou através de [sudo]."
  exit 3;
fi

# Nome do usuário e senha que acessará a base
# de dados FirebirdSQL
FB_USER='SYSDBA'
FB_PASSWORD='masterkey'
GBAK="/usr/bin/gbak"
#
# Preparando o disco que armazenará o backup
#
ponto_device=""
ponto_origem=""
ponto_fs=auto
ponto_montagem=/media/usbdisk

# Defina onde ficará o log desse backup
backup_log_folder="/var/log/firebird/backup/`date +%Y-%m`";

# Insira os UUIDs usados para manter o backup
# Isso permitirá que este script faça backup
# apenas em discos previamente identificados
# pode ser usado qualquer disco,
# incluindo pendrives e cartoes SSD
# Para saber o UUID dos discos inseridos :
# ls -l /dev/disk/by-uuid/
disco[0]="C91C-DA27"  # meu pendrive pessoal usando vfat
disco[1]="dbf9372a-fd1e-4a5a-9e9d-011c9b093380"  # disco externo ext2 sata da empresa #1
disco[2]="ff44fe91-e61e-4d42-9d8c-6fa4ba6e9571"  # disco externo ext2 sata da empresa #1
disco[3]="4c93fef0-82f7-409e-b294-84d19b06c228"  # disco externo ext2 sata da empresa #1
disco[4]="6113ec83-d13e-4e16-9938-6faa2bbb7f72"  # disco externo ext2 sata da empresa #1
disco[5]="821be611-5106-4db6-9fb2-30b98c74ec52"  # use a mesma logica para acrescentar mais discos
for disco_plugado in "${disco[@]}" ; do
  if [ -e "/dev/disk/by-uuid/$disco_plugado" ] ; then
    echo "Encontrado disco de backup :"
    ponto_device="/dev/disk/by-uuid/$disco_plugado"
    ponto_device=`find /dev/disk/by-uuid/ -type l -printf "%f\t%l\n" | grep "$disco_plugado"|cut  -f 2`
    ponto_device=`echo /dev/${ponto_device//\//\.}|tr -d "."`
    echo "UDEV disco detectado em $ponto_device"
  fi
done

### se nao foi encontrado nenhum disco entao abandona
### o script.
if [ "$ponto_device" = "" ] ; then
  echo "Nenhuma unidade de backup foi detectada!"
  exit 2;
fi
echo "ponto_device=$ponto_device"
# verificando se a particao existe realmente
fs_existe=`/sbin/fdisk -l|grep $ponto_device|wc -l`
if [ "$fs_existe" -eq 0 ] ; then
  echo "A particao indicada nao existe :"
  echo $ponto_device
  echo "operacao abortada !";
  exit 1;
fi;

### o disco detectado nao pode estar montado
### isso previne que discos que façam parte do
### sistema -que nascem montados- nao sejam escaneados
fs_existe=`/bin/mount|grep $ponto_device|wc -l`
if [ $fs_existe -gt 0 ] ; then
  echo "A particao indicada ja existe e esta montada :"
  echo $ponto_device
  echo "operacao abortada !";
  exit 1;
fi;

### desmontando a unidade USB se ela estiver montada
if [ "`mount |grep $ponto_device|wc -l`"  -gt 0 ] ; then
  umount $ponto_device
  if [ $? -ne 0 ] ; then
    echo "Erro ao tentar desmontar $ponto_device."
    echo "desmonte-a manualmente e repita a operacao."
    echo "operacao cancelada."
    exit 2;
  fi
fi

ponto_destino="$ponto_montagem"

#
# variaives importantes que definem destino do backup
# titulos, etc...
backup_title="backup-`date +%Y-%m-%d`"
file_error_log="$backup_log_folder/$backup_title.log"
backup_folder="$ponto_destino/`date +%Y-%m-%d`"
backup_inicio="`date +%Y-%m-%d+%H:%M`"
data_ini="`date +%Y-%m-%d+%H:%M`"

if [ -f "$file_error_log" ] ; then
  rm -f "$file_error_log"
  touch "$file_error_log"
  chmod 644 "$file_error_log"
fi

# verificando se o ponto de montagem existe, se nao existir entao cria
if ! [ -d $ponto_destino ] ; then
  mkdir -p $ponto_destino
fi

### desmontando a unidade USB se ela estiver montada
if [ "$ponto_device" != "" ] ; then
  if [ "`mount |grep $ponto_device|wc -l`" -gt 0 ] ; then
    umount $ponto_device
  fi
fi

# montando a unidade de destino, normalmente o usbdisk
do_montar_dev "$ponto_device" "$ponto_destino"
if [ "$RESULT_VALUE" != "OK" ] ; then
  echo "Erro ao montar unidade [$ponto_device] em [$ponto_destino]"
  exit 1;
fi

log "Iniciando backup as $data_inicio"

# criando algumas pastas e arquivos
if ! [ -d "$backup_folder" ] ; then
  echo "criando pasta $backup_folder"
  mkdir -p "$backup_folder"
  if [ $? -ne 0 ] ; then
    log "[backup-falhou] : erro ao criar pasta $backup_folder"
  else
    echo -n "pasta criada."
  fi
fi

if ! [ -d "$backup_log_folder" ] ; then
  mkdir -p "$backup_log_folder"
fi

# preparando arquivo de log
touch $file_error_log

# no relatorio final acrescentando o espaco disponivel
# antes de iniciar o backup :
log "-"
log ".   Espaco na unidade $ponto_device antes de iniciar o backup :"
log ".  `df -h $ponto_device|grep \"Uso\%\"`"
log ".  `df -h $ponto_device|grep \"$ponto_device\"`"
log "-"

### desmontando a unidade USB se ela estiver montada
if [ "$ponto_device" != "" ] ; then
  if [ "`mount |grep $ponto_device|wc -l`" -gt 0 ] ; then
    umount $ponto_device
  fi
fi

echo "Arquivo de log sera gerado em :"
echo "=>$file_error_log"

#
# Variaveis importantes
#

data_ini=`date +%d-%m-%Y+%H:%M`

#########################
# processando o backup  #
#########################
log "[inicio] Relatorio do backup $backup_title iniciado em $data_ini :"

do_backup_firebirdsql

echo "preparando um relatorio para envio..."
data_fim=`date +%d-%m-%Y+%H:%M`

log "[fim] $backup_title iniciado em $data_ini ate $data_fim"

# Fim do Programa