vrms's questions

Tenho um arquivo local file1e também a soma de verificação sha256 do arquivo original.

O controle remoto é uma rhel8 serverferramenta local sha256sumdentro de um git bashlaptop com Windows 10.

Pelo amor de Deus, parece que não consigo comparar esses dois de uma maneira razoável.

no controle remoto eu pego

~> sha256sum file1
55dcd0a7046a24e5ee296d1481d6f787b1956d138bbfb6e44ca8591006367f27  file1

então minha pergunta é... como comparar essa soma criada localmente com a soma de verificação que obtive remotamente?

Eu presumo que deve haver uma maneira de fazer isso com o sha256sumpróprio comando que, de alguma forma, emite checksum matchesouchecksum differs

ou é realmente necessário confiar na sua visão para comparar esses dois ou criar arquivos de texto extras contendo cada soma de verificação e executar uma comparação entre eles?

a melhor maneira que posso pensar é

echo [sha of the remote file] ; sha256sum file1
55dcd0a7046a24e5ee296d1481d6f787b1956d138bbfb6e44ca8591006367f27
55dcd0a7046a24e5ee296d1481d6f787b1956d138bbfb6e44ca8591006367f27 *file1

... e então comparar essas duas linhas usando minha visão nua.

não há nada melhor?

o manual diz

       -c, --check
              read SHA256 sums from the FILEs and check them

mas o que isso significa na prática? sha256sum file1 --check [sha of the remote file]Pareceria lógico para mim, mas não funciona.

Nem faz

:~> sha256sum file1 --check
sha256sum: file1: no properly formatted SHA256 checksum lines found

Quero executar esta função no login como usuário postgres

postgres@servcer:~/.bash.d/functions> cat check_pg-instances.func

#!/usr/bin/bash

# ##############################################################################
#
# function to detect all running postgres instances and check them with pg_isready
#
# ##############################################################################

is_primary()    {
                pg_port=$1
                primary=$(  psql -p "${pg_port}" -tc "SELECT state FROM pg_stat_replication ;" )
                secondary=$(psql -p "${pg_port}" -tc "SELECT client_hostname FROM pg_stat_replication ;" \
                        | cut -d '.' -f1 | sed "s/^ //" )
                }


is_replica()    {
                pg_port=$1
                replica=$(psql -p "${pg_port}" -tc "SHOW primary_conninfo ;" | head -1 | sed "s/^ //" )
                main=$(   psql -p "${pg_port}" -tc "SHOW primary_conninfo ;" | head -1 | sed "s/^ //" \
                        | awk {'print $3'} | sed "s/'//g" | cut -d '=' -f 2 | cut -d '.' -f 1 )
                }


replication_status()    {
                        if [[ -n ${primary} ]] ; then
                                echo replicated by \> "${secondary}"
                        elif [[ -n ${replica} ]] ; then
                                echo replicating from \< "${main}"
                        else
                                echo STANDALONE
                        fi
                        }

function check_pg-instances() {

      # make sure we are at the right location #################################
      cd "$PGBIN" || exit

      # variables ##############################################################
      local instance_names=($(grep PGPORT= .pg*.env | sort -t '=' -k2,2 | cut -d '.' -f2  |  sed "s/^pg-//" ))
      local ports=($(grep PGPORT= .pg*.env | cut -d '=' -f2 | sort -t '=' -k2,2 | tr '\n' ' ' ))
      local counter=$( echo "${instance_names[@]}" | wc -w )
      local count=0

      echo ; echo ================================================================================

      while [[ "${counter}" -gt 0 ]] ; do


         if $(psql -p ${ports[$count]} -l >/dev/null 2>&1) ; then
             is_primary ${ports[$count]}
             is_replica ${ports[$count]}
         fi

         echo -e "postgres $( pg_isready -p ${ports[$count]} | sed "s#/tmp:${ports[$count]} - ##" ) | port: ${ports[$count]} | ${instance_names[$count]} \
         | $(replication_status)"

         counter=$(( "${counter}" - 1 ))
         count=$(( "${count}" + 1 ))
      done

      echo ================================================================================ ; echo

}

atualmente eu lido com isso ~/.bashrccomo

# User specific functions ######################################################
test -d ~/.bash.d/functions && . ~/.bash.d/functions/*.func || true

# check postgres instances #####################################################
check_pg-instances

Agora, minha pergunta é se isso é inteligente ou talvez seja melhor colocar tudo isso (carregar os functions/*.funcarquivos e executar check_pg_instances) em um script e executá-lo na inicialização.

Posso imaginar que, da maneira como estou fazendo agora, eu possa ter essa(s) função(ões) na memória durante toda a sessão e não apenas quando ela for realmente necessária.

Eu tenho o mesmo tipo de trabalho para 10 instâncias paralelas do postgres em um único servidor. Eles devem funcionar a cada 6 horas, mas não todos no mesmo horário.

11 */6 * * * my_commandcorre em 0:11, 6:11, 12:11,18:11

Para que eu possa separá-los um do outro com os meios de definir o minuto (30 minutos no máximo). Mas eu gostaria de mais, como correr 0,6,12,18versus correr, ou seja2,8,14,20

então minha pergunta é ... existe uma maneira de ter outro trabalho em execução 2:11, ou seja 8:11, , 14:11,20:11

ou devo dizer 11 */6 * * * sleep 120m && my_commandpara a execução alternativa?

Eu quero ser saudado por

# #####################################################
# ### PostgreSQL 16.3 #################################
# #####################################################

no login em um servidor postgres.

então eu adiciono

echo "# #####################################################"
psql -qAtc "SELECT version()" | awk {'print $1, $2'}
echo "# #####################################################"

para o ~/.bashrc.

Agora provavelmente preciso de algum tipo de echowith $(psql -qAtc "SELECT version()" | awk {'print $1, $2'}), mas não consigo descobrir como adicionar o início/final #a ele.

Alguém pode me indicar a direção certa aqui?

O vim é capaz de abrir diretórios (e navegar neles).

vim roles/webservices/tasks/

" ============================================================================
" Netrw Directory Listing                                        (netrw v156)
"   /home/gwagner/repos/automation_postgres/roles/webservices/tasks
"   Sorted by      name
"   Sort sequence: [\/]$,\<core\%(\.\d\+\)\=\>,\.h$,\.c$,\.cpp$,\~\=\*$,*,\.o$,\.obj$,\.info$,\.swp$,\.bak$,\~$
"   Quick Help: <F1>:help  -:go up dir  D:delete  R:rename  s:sort-by  x:special
" ==============================================================================
../
./
download_file.yml
main.yml
post_data.yml
post_du.yml
~

Agora, é possível voltar para o navegador de diretório dentro do vim ao fechar um arquivo? :wq, :q, :xjoga você de volta na festa de onde você veio

Desejo executar um despejo postgres de um servidor remoto, o que levará algumas horas. Estou usando um script bash no destino para fazer isso e iniciá-lo comat

Agora, para evitar que as coisas quebrem eu uso nohup, mas não tenho certeza se isso é necessário (devido a iniciar o script com at) e se seria melhor usar in no pg_dumpcomando diretamente (veja abaixo) ou iniciar o script nohupe pule-o no próprio comando.

comando no script atualmente é:

nohup nice pg_dump -h ${SOURCE} -d ${DB_NAME} -U ${DB_USER} -v -Fd -j 2 \
-f ${DUMPDIR}/${DUMPFILE}_"${NOW}" >  ${DUMPDIR}/${DUMPFILE}_"${NOW}".out

• Estou obtendo uma saída linear do grep como ...

value1
value2
value3

• para preencher uma variável para um script bash, preciso transformá-lo em formato embutido, como ('value1' 'value2' 'value3')embora.

Na realidade, existem mais de 40 valores, então estou procurando um fluxo de trabalho automatizado em vez de apenas fazê-lo manualmente.

como eu faria isso?

Sou muito novo no uso de at e estou me perguntando como exibir o comando por um trabalho agendado.

postgres@dcjsn-jv2526:/opt/db/backup/postgres/dumps> atq
29      Wed Nov  2 18:55:00 2022 a postgres

Vejo que há um trabalho 29 agendado para um determinado horário por um determinado usuário. Agora quero examinar o comando a ser executado. Como faço para conseguir isso? Não há nada sobre isso na página de manual.