GerenciamentoDRM.sh

#!/bin/sh
#
# GerenciamentoDRM.sh
#
# Autor: Aecio Paes Barreto <[email protected]> 13 de marco de 2014.
#
# Descrição: Gerenciamento de DRM/TSM Server.
#
# Obs..: Nenhuma.
#
# Versão 1: Criado o script.

##-------------------------------------------------------------------------------##
##################### Variaveis de Configuracao ###################################
##-------------------------------------------------------------------------------##

ID=admin
PASSWD=admin
DirBase=/opt/tivoli/tsm/server/scripts/GerenciamentoDRM
MailList=""
MailListAdm=""
BkpRFiles_LoginRemoto=root
BkpRFiles_ServidorRemoto=sfxxxxxxxx
BkpRFiles_PathRemoto=/var/www/linux/servertool/TSM_arquivos
BkpRFiles_Destino="$BkpRFiles_LoginRemoto@$BkpRFiles_ServidorRemoto:$BkpRFiles_PathRemoto"

##-------------------------------------------------------------------------------##
##################### Variaveis do Script #########################################
##-------------------------------------------------------------------------------##

DaysDelVolHist=3
BaseName=$( basename $0 | sed 's/.sh//g' )
BinDSM=/usr/bin/dsmadmc
DirTmp=$DirBase/tmp
DirLog=$DirBase/logs
DirControle=$DirBase/controles
DirConfig=$DirBase/etc
ArquivoLog=$DirLog/$BaseName.log
ArquivoConfig=$DirConfig/$BaseName.conf
ArquivoLock=$DirTmp/$BaseName.lck
ArquivoVolhistoryDB=$DirControle/VOLHISTORYDB.controle

##-------------------------------------------------------------------------------##
##################### Funcoes #####################################################
##-------------------------------------------------------------------------------##

## Imprime data
_TimeStamp(){ date "+%Y/%m/%d,%H:%M:%S"; }

## Registra informacoes no arquivo de log
_Logger(){ echo -e "$@" >> $ArquivoLog;}

## Gera path p/ arquivo temporario
_ArquivoTmp(){ echo "$DirTmp/$BaseName.`date +%N`.$RANDOM.tmp"; }

## Garante execucao unica do script
_ChecaExecucao(){
   RC=0
   if [ -f $ArquivoLock ]; then
      PID=$( cat $ArquivoLock )
      echo O script ja esta em execucao PID $PID
      RC=1
   else
      echo $$ > $ArquivoLock
   fi
   return $RC
}

## Submete comandos no DSMADMC.
_ComandoDSM(){
   $BinDSM -id=$ID -password=$PASSWD "$@"
   return $?
}

## Backup remoto dos scripts TSMServer
_BackupScripts(){

   local RC=0
   
   ArquivoScripts=$( _ArquivoTmp )
   Destino="$BkpRFiles_Destino/TSMScripts.txt"

   local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoScripts "QUERY SCRIPT FORMAT=DETAILED" ) || RC=$?
   unset Null

   if [ $RC -eq 0 ]; then
      scp $ArquivoScripts $Destino || RC=$?
      if [ $RC -eq 0 ]; then
         Mensagem="`_TimeStamp`,sucesso scp,copia TSMScripts ($Destino)"
      else
         Mensagem="`_TimeStamp`,erro scp,copia TSMScripts ($Destino)"
      fi
   else
      Mensagem="`_TimeStamp`,erro dsmadmc,copia TSMScripts"
   fi

   _Logger "$Mensagem" && echo "$Mensagem" 
   [ -f $ArquivoScripts  ] && rm -rf $ArquivoScripts > /dev/null 2>&1
   return $RC

}


## Backup remoto de arquivos de configuracao
_BackupRecoveryFiles(){

   local RC=0
   local Arquivo1=/u2ipts01/devcnfg.out
   local Arquivo2=/u2ipts01/volhist.out
   local Arquivo3=/u2ipts01/dsmserv.opt

   Mensagem="`_TimeStamp`,INF,recoveryfiles\n`_TimeStamp`,destino: $BkpRFiles_Destino"

   scp $Arquivo1 $BkpRFiles_Destino \
      && local MensagemF1="`_TimeStamp`,sucesso copia,($Arquivo1)" \
      || { local MensagemF1="`_TimeStamp`,erro copia,($Arquivo1)"; RC=$?; }

   scp $Arquivo2 $BkpRFiles_Destino \
      && local MensagemF2="`_TimeStamp`,sucesso copia,($Arquivo2)" \
      || { local MensagemF2="`_TimeStamp`,erro copia,($Arquivo2)"; RC=$?; }


   scp $Arquivo3 $BkpRFiles_Destino \
      && local MensagemF3="`_TimeStamp`,sucesso copia,($Arquivo3)" \
      || { local MensagemF3="`_TimeStamp`,erro copia,($Arquivo3)"; RC=$?; }


   _Logger "$Mensagem" && echo -e "$Mensagem"
   _Logger "$MensagemF1" && echo "$MensagemF1"
   _Logger "$MensagemF2" && echo "$MensagemF2"
   _Logger "$MensagemF3" && echo "$MensagemF3"

   return $RC

}

## Valida Storage Pool.
_VerificaStoragePool(){

   local RC=0

   if [ $# -eq 1 ]; then

      StgPoolName=$1
      $BinDSM -id=$ID -password=$PASSWD "select * from STGPOOLS where STGPOOL_NAME='$StgPoolName' and POOLTYPE='COPY'" > /dev/null 2>&1 || RC=$? 
   else
      echo "Forneca o nome do POOL"
      RC=1
   fi
   return $RC
}

_ValidaLibrary(){
   if [ $# -eq 1 ]; then
      local RC=0
      local Library=$1
      local Null=$( _ComandoDSM "QUERY LIBRARY $Library" > /dev/null 2>&1 ) || RC=$?
      unset Null
   else
      echo Forneca o nome da Library
      RC=1
   fi
   return $RC
}

## Imprime Device Class usado no Backup DB.
_DevClassBackupDB(){

   local StgPoolName=$1
   local RC=0

   local ArquivoTmp1="$( _ArquivoTmp )"
   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1

   local Query="select DEVCLASS from volhistory where TYPE='BACKUPFULL'"
   local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTmp1 "$Query" )
   unset Null Query

   local DevClass=$( grep DCL $ArquivoTmp1 | sort | uniq )
   echo $DevClass

   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1
}

## Imprime Library associada ao DeviceClass usado no Backup DB.
_LibraryBackupDB(){

   local RC=0

   local ArquivoTmp1="$( _ArquivoTmp )"
   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1
   touch $ArquivoTmp1
   local SubQuery="select DEVCLASS from volhistory where TYPE='BACKUPFULL' group by DEVCLASS"
   local Query="select * from devclasses where DEVCLASS_NAME in ( $SubQuery )"
   local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTmp1 "$Query" )
   unset Null SubQuery Query
   local Library=$( awk '/LIBRARY_NAME: / {print $2}' $ArquivoTmp1 )
   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1
   echo $Library
}

## Lista midias com Status Full e acesso RW.
## Usado para fazer CHECKOUT de volumes.
_ListarMidiasFullRW(){

   local StgPoolName=$1
   local RC=0

   local ArquivoTmp1="$( _ArquivoTmp )"
   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1
   touch $ArquivoTmp1

   local Query="select * from volumes where STGPOOL_NAME='$StgPoolName' and STATUS='FULL' and ACCESS='READWRITE'"
   local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTmp1 "$Query" )
   unset Null Query StgPoolName

   local TotalFitas=$( awk '/VOLUME_NAME: / {print $2}' $ArquivoTmp1 | wc -l )

   if [ $TotalFitas -gt 0 ]
   then
      awk '/VOLUME_NAME: / {print $2}' $ArquivoTmp1
   else
      echo "00000000"
      RC=1
   fi

   rm -rf $ArquivoTmp1 > /dev/null 2>&1

   return $RC
}

_ListarMidiasDBEmptyOffsite(){

   local ArquivoTmp1="$( _ArquivoTmp )"
   #awk '/Volume Name: / {print $3}' $ArquivoVolhistoryDB > $ArquivoTmp1
   awk '/VOLUME_NAME: / {print $2}' $ArquivoVolhistoryDB > $ArquivoTmp1
   
   Quantidade=$( wc -l $ArquivoTmp1 | cut -d\  -f1 )
   if [ $Quantidade -ge 1 ]; then
      cat $ArquivoTmp1
   else
      echo 00000000
   fi
   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1

}


## Lista volumes com Status Empty e Acesso OffSite.
## Usado para listar fitas a serem reintegradas.
_ListarMidiasEmptyOffsite(){
   local StgPoolName=$1
   local RC=0

   local ArquivoTmp1="$( _ArquivoTmp )"
   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1
   touch $ArquivoTmp1

   local Query="SELECT VOLUME_NAME FROM VOLUMES WHERE STGPOOL_NAME like '$StgPoolName' and ACCESS='OFFSITE' and STATUS='EMPTY'"
   local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTmp1 "$Query" )
   unset Null Query StgPoolName

   local TotalFitas=$( awk '/VOLUME_NAME: / {print $2}' $ArquivoTmp1 | wc -l )

   if [ $TotalFitas -gt 0 ]
   then
      awk '/VOLUME_NAME: / {print $2}' $ArquivoTmp1
   else
      echo "00000000"
      RC=1
   fi
   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1
   return $RC

}

## Imprime Library assoc a DEVCLASS de um STGPOOL fornecido como argumento.
_LibraryPool(){

   RC=0
   if [ $# -eq 1 ]
   then
      local ArquivoTmp1="$( _ArquivoTmp )"
      [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1
      touch $ArquivoTmp1
      local StgPoolName=$1
      local ComandoTSM="select * from devclasses where DEVCLASS_NAME=(select DEVCLASS from STGPOOLS where STGPOOL_NAME='$StgPoolName')"

      local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTmp1 "$ComandoTSM" )
      local NomeLibrary=$( awk '/LIBRARY_NAME: / { print $2 }' $ArquivoTmp1 )
      echo $NomeLibrary

      rm -rf $ArquivoTmp1 > /dev/null 2>&1

   else
      echo Forneca o nome do pool
   fi

}

## Imprime lista com volumes utilizados no backup DB.
_ListarMidiasBackupDB(){

   local RC=0
   local DiaDaSemana=$( date +%u )
   if [ $DiaDaSemana -eq 1 ]; then

      local Data=$( date +%Y-%m-%d -d "- 2 day" )
      local ComandoTSM="select * from volhistory where TYPE='BACKUPFULL' and DATE_TIME>'$Data 00:00:00'"

   else

      local Data=$( date "+%Y-%m-%d" )
      local ComandoTSM="select * from volhistory where TYPE='BACKUPFULL' and DATE_TIME like '$Data%'"

   fi

   local ArquivoTmp1="$( _ArquivoTmp )"
   [ -f $ArquivoTmp1 ] && rm -rf $ArquivoTmp1 > /dev/null 2>&1

   local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTmp1 "$ComandoTSM" ) || RC=$?
   unset Null Query


   local TotalFitas=$( awk '/VOLUME_NAME: / {print $2}' $ArquivoTmp1 | wc -l )

   if [ $TotalFitas -gt 0 ]
   then
      awk '/VOLUME_NAME: / {print $2}' $ArquivoTmp1
   else
      echo "00000000"
      RC=1
   fi

   rm -rf $ArquivoTmp1 > /dev/null 2>&1
   return $RC

}

## Realiza CHECKOUT de volume.
## Parametro 1: LIBRARY
## Parametro 2: STORAGE POOL
## Parametro 3: VOLUME
_CheckOutVolume(){

   if [ $# -eq 3 ]; then
      local RC=0
      local LibraryName=$1
      local PoolName=$2
      local VolumeName=$3

      local ComandoTSM_CHECKOUT="CHECKOUT LIBVOLUME $LibraryName $VolumeName REMOVE=BULK CHECKLABEL=NO"

      case $PoolName in
         ITSM-DB)
	    local DevClassBackupDB=$( _DevClassBackupDB )
	    local ComandoTSM_UPDATE="UPDATE VOLHISTORY $VolumeName DEVCLASS=$DevClassBackupDB LOCATION='COFRE EXTERNO'"
	 ;;

	 *)
	    local ComandoTSM_UPDATE="UPDATE VOLUME $VolumeName ACCESS=OFFSITE LOCATION=\"COFRE EXTERNO\" WHERESTGPOOL=$PoolName"
	 ;;
      esac

      local Null=$( $BinDSM -id=$ID -password=$PASSWD "$ComandoTSM_CHECKOUT" ) || RC=$?
      if [ $RC -eq 0 ]; then
         local Null=$( $BinDSM -id=$ID -password=$PASSWD "$ComandoTSM_UPDATE" ) || RC=$?
      else
         echo Erro no ckeckout $LibraryName $VolumeName
         RC=2
      fi

   else
      echo Forneca o Nome da library o pool e o nome do volume a ser feito checkout
      RC=1
   fi
   return $RC

}

## Realiza CHECKIN de volume.
## Parametro 1: LIBRARY
## Parametro 2: DESTINO (COPYPOOL ou TSM-DB)
## Parametro 3: VOLUME
_CheckInVolume(){
   if [ $# -eq 3 ]; then
      local RC=0
      local Library=$1
      local Destino=$2
      local Volume=$3
      local ArquivoControle=$DirControle/$LibraryName.reintegrar.dat
      local Lista=$( cut -d\: -f2 < $ArquivoControle | tr -s '\n' ',' )
      case $Destino in
         ITSM-DB)
	    local ComandoTSM_UPDATE="UPDATE VOLUME $Volume ACCESS=READWRITE LOCATION=\"\""
	 ;;

	 *)
	    local ComandoTSM_UPDATE="UPDATE VOLUME $Volume ACCESS=READWRITE LOCATION=\"\" WHERESTGPOOL=$Destino WHEREACCESS=OFFSITE WHERESTATUS=EMPTY"
	 ;;
      esac
      
       local Null=$( _ComandoDSM "$ComandoTSM_UPDATE" ) || RC=$?
       if [ $RC -eq 0 ]; then
          #### CHECKIN ALTERADO PARA FAZER CHECKIN DE VOLUMES INSERIDOS FORA DE ORDEM NO BULK ####
          Null=$( _ComandoDSM "CHECKIN LIBVOLUME $Library SEARCH=BULK VOLLIST=$Lista STATUS=SCRATCH CHECKLABEL=BARCODE WAITTIME=0" ) || RC=$?

	  if [ $RC -eq 0 ]; then
	     local FimCHK=0
             local ArquivoTmp=$( _ArquivoTmp )
             while [[ $FimCHK -eq 0  ]]
	     do
	        sleep 10
                local Query="SELECT * FROM PROCESSES WHERE PROCESS like '%CHECKIN%'"
		Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTmp "$Query" ) || FimCHK=$?
	     done
             [ -f $ArquivoTmp ] && rm -rf $ArquivoTmp > /dev/null 2>&1

	     local ArquivoTmp="$( _ArquivoTmp )"
             sleep 10
	     local Query="select * from libvolumes where VOLUME_NAME='$Volume'"
	     local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTmp "$Query" )
             unset Null

             #Status=$( awk -F '[:]' '/STATUS/ {print $2}' < $ArquivoTmp )
	     #if [ ".$Status" == ". Scratch" ]; then

             grep --quiet "Scratch" $ArquivoTmp
	     local ScratchRC=$?
             if [ $ScratchRC -eq 0 ]
             then
	        echo "  <$Volume OK - REINTEGRADO"
		_Logger "`_TimeStamp`,$VolumeName,vol_reintegrado,library [ $Library ]"
	     else
	        RC=15
		echo "  !<$Volume ERRO - NAO REINTEGRADO"
		_Logger "`_TimeStamp`,$VolumeName,vol_nao_reitegrado,library [ $Library ]"
             fi

	     [ -f $ArquivoTmp ] && rm -rf $ArquivoTmp > /dev/null 2>&1
	     unset Null
	  else
	     echo erro invocando ckeckin
	  fi
       else
          echo erro no updade volume
       fi
   else
      RC=1
      Saida="Forneca a lib e o volume"
   fi
   return $RC
}

## Levanta volumes a serem liberados. (Status FULL RW)
_MidiasLiberar(){

   if [ $# -eq 1 ]; then
      local RC=0
      local StgPoolName=$1

      case $StgPoolName in
      ITSM-DB)
      echo -e "\nITSM-DB ( BACKUPFULL ):\n"

         local DevClassBackupDB=$( _DevClassBackupDB )
	 local LibraryBackupDB=$( _LibraryBackupDB )

         _ListarMidiasBackupDB | \
         while read VolumeName
         do
            if [ $VolumeName != "00000000" ]
	    then
                _CheckOutVolume $LibraryBackupDB ITSM-DB $VolumeName
		echo "  >$VolumeName"
		_Logger "`_TimeStamp`,$VolumeName,vol_liberado,dbb ( ITSM-DB )"
	    else
	       echo " ...Nao ha volumes BD a ser liberado (o backup db ainda nao foi feito)."
	       break
            fi
         done 
      ;;

      *)
         # Valida pool
         _VerificaStoragePool $StgPoolName || RC=$?
         if [ $RC -eq 0 ]; then
	 echo -e "\nCopyPool ( $StgPoolName ):\n"
	    local LibraryName=$( _LibraryPool $StgPoolName )
            _ListarMidiasFullRW $StgPoolName | \
            while read VolumeName
            do
               if [ "$VolumeName" != "00000000" ]
               then
                  _CheckOutVolume $LibraryName $StgPoolName $VolumeName
		  echo "  >$VolumeName"
		  _Logger "`_TimeStamp`,$VolumeName,vol_liberado,drm ( $StgPoolName )"
               else
                  echo " ...Nao ha volumes a serem liberados do STGPOOL $StgPoolName"
                  break
               fi
            done
         else
            echo Storage Pool Inexistente ou tipo nao copia.
         fi
      ;;
      esac
   else
      echo Use corretamente os parametros
   fi
}

_MidiasReintegrar(){

   if [ $# -eq 1 ]
   then
      local Parametro=$1
      local StgPoolName=$Parametro
      case $Parametro in
         ITSM-DB)

            Library=$( _LibraryBackupDB )
	    echo -e "\nLibrary $Library ( ITSM-DB ):\n"
            local ArquivoControle=$DirControle/$Library.reintegrar.dat
	    [ ! -f $ArquivoControle ] && touch $ArquivoControle
           
	    _ListarMidiasDBEmptyOffsite | \
	    while read VolumeName
	    do
               if [ "$VolumeName" != "00000000" ]; then
	          echo "  <$VolumeName"
	          grep --quiet $VolumeName $ArquivoControle || \
                  { 
                     echo "ITSM-DB:$VolumeName" >> $ArquivoControle
	             _Logger "`_TimeStamp`,$VolumeName,a_reintegrar,dbb( ITSM-DB )"
                  }
                  else
                     echo " ...Nao ha volumes DB (backupfull) para ser reintegrado"
                  fi
	    done
	 
	 ;;
	 *)
            # Valida pool
	    _VerificaStoragePool $StgPoolName || RC=$?
	    if [ $RC -eq 0 ]; then
               local Library=$( _LibraryPool $Parametro )
               local ArquivoControle=$DirControle/$Library.reintegrar.dat
	       [ ! -f $ArquivoControle ] && touch $ArquivoControle
               echo -e "\nLibrary $Library ( $StgPoolName ):\n"

	       ### Lista Midias EMPTY/OFF de POOL fornecido
	       _ListarMidiasEmptyOffsite $Parametro | \
	       while read VolumeName
	       do
                  if [ $VolumeName != '00000000' ]
                  then
		     echo "  <$VolumeName"
		     grep --quiet $VolumeName $ArquivoControle || \
                     {
		        echo "$StgPoolName:$VolumeName" >> $ArquivoControle
		        _Logger "`_TimeStamp`,$VolumeName,a_reintegrar,drm( $StgPoolName )"
		     }
                  else
		     echo " ...Nao ha volumes para ser reintegrado"
                  fi
	       done
	    fi
	 ;;
      esac
   else
      echo Forneca o nome do CopyPool
   fi
}

_QtdSlotsDisponiveis(){

   local LibraryName=$( echo "$1" | tr [:lower:] [:upper:] )

   local ArquivoTMP1=$( mktemp )
   local ArquivoTMP2=$( mktemp )

   local ComandoDSMSlots="SHOW SLOTS $LibraryName"
   local ComandoDSMVolumes="select count(*) from LIBVOLUMES where library_name like '%$LibraryName%'"

   local Null1=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoTMP1 "$ComandoDSMSlots" )
   local Null2=$( $BinDSM -id=$ID -password=$PASSWD -dataonly=yes -outfile=$ArquivoTMP2 "$ComandoDSMVolumes" )
   unset Null1 Null2

   local QtdSlots=$(  awk '/Slots            : / {print $3}' $ArquivoTMP1 )
   local QtdVolumes=$( grep "[0-9]" $ArquivoTMP2 | tr -d ' ' )

   local QtdSlotsDisponiveis=$( expr $QtdSlots - $QtdVolumes )

   [ -f $ArquivoTMP1 ] && rm -rf $ArquivoTMP1 > /dev/null 2>&1
   [ -f $ArquivoTMP2 ] && rm -rf $ArquivoTMP2 > /dev/null 2>&1

   echo $LibraryName $QtdSlotsDisponiveis

}

_QtdVolsReintegrar(){

   local LibraryName=$1
   local ArquivoControle=$DirControle/$LibraryName.reintegrar.dat
   local QtdVolsReintegrar=$( grep \. -c $ArquivoControle )

   echo $QtdVolsReintegrar

}

_ReintegrarVolumes(){
   local RC=0
   if [ $# -eq 1 ]
   then
      local LibraryName=$1
      local ArquivoControle=$DirControle/$LibraryName.reintegrar.dat
      _ValidaLibrary $LibraryName || RC=$?
      if [ $RC -eq 0 ]; then
         if [ -f $ArquivoControle ]; then
	    echo -e "\nReintegracao de volumes $LibraryName\n"
            ## ----- Fracionando a reintegracao ----- ##
            local QtdSlotsDisponiveis=$( _QtdSlotsDisponiveis $LibraryName )
            local QtdVolsReintegrar=$( _QtdVolsReintegrar $LibraryName )
            if [ $QtdSlotsDisponiveis -gt 0 ]; then
               if [ $QtdSlotsDisponiveis -ge $QtdVolsReintegrar ]; then
                  ################# reintegrar tudo #################
            	  if [ $QtdVolsReintegrar -le 6 ]; then
            	     # Reintegrar de uma unica vez.
                     ## >>>------- laco -------<<< ##
                     while read Volume
                     do
                        local Destino=$( echo $Volume | cut -d\: -f1 )
                        local VolumeName=$( echo $Volume | cut -d\: -f2 )
                        _CheckInVolume $LibraryName $Destino $VolumeName
                     done < $ArquivoControle
                     ## >>>------ fim laco ------<<< ##
            	  else
                     ################# Fracionar e sinalizar etapas #################
            	     local ArqTemp=$( mktemp )
            	     local QtdEtapas=$( [ `echo $(($QtdVolsReintegrar % 6))` -ne 0 ] && echo "$((( $QtdVolsReintegrar / 6)+1))" || echo "$(( $QtdVolsReintegrar / 6 ))" )
            	     for (( i = 1; i <= $QtdEtapas; i++ ))
                     do
                        head -n6 $ArquivoControle > $ArqTemp
                        sed -i '1,6d' $ArquivoControle
                        ## >>>------- laco -------<<< ##
                        # Sinaliza
			{ echo "Garanta os volumes abaixo no bulk da $LibraryName."; cat $ArquivoControle; } | \
			mail -s "ITSM/DRM - Reintegracao ( $i/$QtdEtapas ) - Inserir Volumes" $MailListAdm
			# Aguarda
			sleep 900

            		while read Volume
            		do
            		   local Destino=$( echo $Volume | cut -d\: -f1 )
            		   local VolumeName=$( echo $Volume | cut -d\: -f2 )
            		   _CheckInVolume $LibraryName $Destino $VolumeName
            		done < $ArqTemp
            		## >>>------ fim laco ------<<< ##
            		rm -rf $ArqTemp > /dev/null 2>&1
            	     done
            	  fi
               else
                  ################# Reitegra o que couber #################
                  echo "Reitegracao feita conforme disponibilidade de slots [ $QtdSlotsDisponiveis ]"
                  local ArqTemp=$( mktemp )
                  head -n $QtdSlotsDisponiveis $ArquivoControle > $ArqTemp
                  ## >>>------- laco -------<<< ##
                  while read Volume
                  do
                     local Destino=$( echo $Volume | cut -d\: -f1 )
                     local VolumeName=$( echo $Volume | cut -d\: -f2 )
                     CheckInVolume $LibraryName $Destino $VolumeName
                  done < $ArqTemp
                  ## >>>------ fim laco ------<<< ##
		  rm -rf $ArqTemp > /dev/null 2>&1
               fi
            else
	       ################# Nao reintegra #################
               echo "Nao ha slots disponiveis na library \"$LibraryName\" para reintegracao de \"$QtdVolsReintegrar\" volumes"
            fi
            ## ---------------------------------------- ##
            > $ArquivoControle 
	 else
	    echo Arquivo de controle inexistente
	 fi
      else
         echo Library invalida
      fi
   else
      echo Forneca o nome da library como parametro
   fi
}

_ApurarVolhistoryDB(){

   ### 1. Relacionar VOLHIST-BACKUPFULL a serem reintegrados.
   ###    redirecionar pra arquivo a ser utilizado na funcao _MidiasReintegrar

   #local Comando='QUERY VOLHISTORY TYPE=DBBACKUP ENDDATE=TODAY-3'
   #local Comando='QUERY VOLHISTORY TYPE=DBBACKUP'
   local DataDelete=$( date +%Y-%m-%d -d "- $DaysDelVolHist day" )
   #local Comando="SELECT * FROM VOLHISTORY WHERE TYPE='BACKUPFULL' and DATE_TIME between '$DataDelete 00:00:00' and '$DataDelete 23:59:59'"
   local Comando="SELECT * FROM VOLHISTORY WHERE TYPE='BACKUPFULL' and DATE_TIME<'$DataDelete 23:59:59'"
   local Null=$( $BinDSM -id=$ID -password=$PASSWD -outfile=$ArquivoVolhistoryDB "$Comando" )
   unset Null

}

_BackupDB(){

   ### 2. Executar script TSM BACKUP-DB.
   Null=$( _ComandoDSM "run backup-db" > /dev/null 2>&1 )
   unset Null
}

_Liberar(){

   if [ -f $ArquivoConfig ]; then
      echo -e "\n--- Inicio ---\n"
      echo "ITSM/DRM - MOVIMENTO DIARIO DE VOLUMES"
      echo -e "\nI) Volumes Liberados (Library >> Cofre Externo)"
      awk -F '[=]' '/DRM/ { print $2 }' $ArquivoConfig | \
      while read DRM
      do
         ## Checkout de volumes full a ser enviado OFFSITE;
         _MidiasLiberar $DRM
      done
      ### BACKUP DB ###
      echo -e "\nII) Volumes a Reintegrar (Library << Cofre Externo)"

      awk -F '[=]' '/DRM/ { print $2 }' $ArquivoConfig | \
      while read DRM
      do
         ## Relaciona volumes EMPTY OFFSITE a serem reintegradas;
         _MidiasReintegrar $DRM
      done
      echo -e "\n--- Fim ---\n"

   else
      echo Arquivo de Configuracao inexistente  $ArquivoConfig 
   fi
}

_Reintegrar(){

   if [ -f $ArquivoConfig ]; then

      echo -e "\n--- Inicio ---\n"
      echo "ITSM/DRM - MOVIMENTO DIARIO DE VOLUMES"
      echo -e "\n"

      awk -F '[=]' '/LIB/ { print $2 }'  $ArquivoConfig | \
      while read LIB
      do
         _ReintegrarVolumes $LIB
      done

      echo -e "\n--- Fim ---\n"

   else
      echo Arquivo de Configuracao inexistente  $ArquivoConfig 
   fi

}

##-------------------------------------------------------------------------------##
##################### Inicio do Script ############################################
##-------------------------------------------------------------------------------##

_ChecaExecucao && {
   if [ $# -eq 1 ]; then
      Parametro=$( echo $1 | tr [:upper:] [:lower:] )
      case $Parametro in

         --backup-recovery-files|-brf)
            { _BackupRecoveryFiles; }  | mail -s "ITSM/DRM - Backup Recovery Files" $MailListAdm
         ;;

         --backup-scripts|-bs)
            { _BackupScripts; }  | mail -s "ITSM/DRM - Backup Scripts" $MailListAdm
         ;;

         --backup-db|-bdb)
            { _BackupDB; }  | mail -s "ITSM/DRM - Backup DB" $MailListAdm
         ;;

         --volhistory-db|-vhdb)
            { _ApurarVolhistoryDB; } # | mail -s "ITSM/DRM - Query Volhistory" $MailListAdm
         ;;

         --liberar|-l)
            { sleep 3600 && _Liberar; }  | mail -s "ITSM/DRM - Movimento Diario - LIBERACAO" $MailList
         ;;

         --reintegrar|-r)
            { _Reintegrar; }  | mail -s "ITSM/DRM - Movimento Diario - REINTEGRACAO" $MailList
         ;;

         --slots)
            _QtdSlotsDisponiveis LIBLTO5
            _QtdSlotsDisponiveis LIBLTO4
            _QtdSlotsDisponiveis LIBLTO3
         ;;


         *)
            echo "Use corretamente os parametros"
         ;;

      esac
   else
      echo "Use corretamente os parametros"
   fi

   [ -f $ArquivoLock ] && rm -rf $ArquivoLock > /dev/null 2>&1
}

##-------------------------------------------------------------------------------##
##################### Fim do Scritpt ##############################################
##-------------------------------------------------------------------------------##