Perguntas[shell-script](unix)

Tenho um script que tem um loop for que é executado um número específico de vezes e queria saber se é possível implementar o comando pv no meu script para adicionar uma barra de progresso.

Aqui está meu código:

for i in $(seq 1 10000000); do
    echo "iteration ${i}"
    #rest of for loop
done

registro:

iteration 1
iteration 2
iteration 3
iteration 4
iteration 5
iteration 6
iteration 7
iteration 8
iteration 9
iteration 10
*and so on

se alguém puder me ajudar com isso, qualquer ajuda será muito apreciada

edição: mudei um pouco o código:

for i in $(seq 1 10000000); do
    echo "iteration ${i}" | pv -l
    #rest of for loop
done

e me deu esta saída:

1
1.00  0:00:00 [15.2k/s] [  <=>                                                                                                                             ]
2
1.00  0:00:00 [14.7k/s] [  <=>                                                                                                                             ]
3
1.00  0:00:00 [15.6k/s] [  <=>                                                                                                                             ]
4
1.00  0:00:00 [15.0k/s] [  <=>                                                                                                                             ]
5
1.00  0:00:00 [15.0k/s] [  <=>                                                                                                                             ]
6
1.00  0:00:00 [11.5k/s] [  <=>                                                                                                                             ]
7
1.00  0:00:00 [5.54k/s] [  <=>                                                                                                                             ]
8
1.00  0:00:00 [14.7k/s] [  <=>                                                                                                                             ]
9
1.00  0:00:00 [13.2k/s] [  <=>                                                                                                                             ]
10
1.00  0:00:00 [13.4k/s] [  <=>                                                                                                                             ]

Eu tenho um script e quando o executo, ele retorna

Directory not found: ~/Pictures/Wallpaper

O roteiro é o seguinte:

#!/bin/bash
# Check if the wallpaper directory exists
if [ ! -d "$WALLPAPER_DIR" ]; then
  echo "Directory not found: $WALLPAPER_DIR"
  exit 1
fi

# Get currently loaded wallpaper
CURRENT_WALL=$(hyprctl hyprpaper listloaded)

# Get a random wallpaper that is not the current one
IMAGE=$(find "$WALLPAPER_DIR" -type f ! -name "$(basename "$CURRENT_WALL")" | -iname "*.jpg" -o -iname "*.png" -o -iname "*.jpeg" | shuf -n 1)

# Verify that an image was found
if [ -z "$IMAGE" ]; then
  echo "No images found in $WALLPAPER_DIR"
  exit 1
fi

A $WALLPAPER_DIRvariável de ambiente está configurada no meu arquivo hyprland.conf e tem o valor ~/Pictures/Wallpaper que eu verifiquei.

Estou bastante perplexo sobre o motivo de ele estar retornando o negativo da instrução if quando a variável e a pasta de fato existem.

Gostaria de passar argumentos longos para o script, e referi este link . Criei este my_script:

#!/usr/bin/env bash
#
# Adapted from https://www.shellscript.sh/examples/getopt/
#
set -euo pipefail

user_type=unset
user_id=unset
country=unset
dev_env=unset
position_id=unset

usage(){
>&2 cat << EOF
Usage: $0]
   [ -a | --user_type input
   [ -b | --user_id input ]
   [ -c | --country input ] 
   [ -d | --dev_env input ]
   [ -e | --position_id input ]
EOF
exit 1
}

>&2 echo [$@] passed to script

args=$(getopt -a -o ha:b:c:d: --long help,user_type:,user_id:,country:,dev_env:,position_id: -- "$@")
if [[ $? -gt 0 ]]; then
  usage
fi

>&2 echo getopt creates [${args}]

eval set -- ${args}
while :
do
  case $1 in
    -a | --user_type)   user_type=$2    ; shift 2  ;;
    -b | --user_id)    user_id=$2     ; shift 2  ;;
    -h | --help)    usage      ; shift   ;;
    -c | --country)   country=$2   ; shift 2 ;;
    -d | --dev_env)   dev_env=$2   ; shift 2 ;;
    -e | --position_id) position_id=$2 ; shift 2 ;;
    # -- means the end of the arguments; drop this, and break out of the while loop
    --) shift; break ;;
    *) >&2 echo Unsupported option: $1
       usage ;;
  esac
done

if [[ $# -eq 0 ]]; then
  usage
fi

>&2 echo "user_type   : ${user_type}"
>&2 echo "user_id    : ${user_id} "
>&2 echo "country   : ${country}"
>&2 echo "dev_env   : ${dev_env}"
>&2 echo "position_id   : ${position_id}"
>&2 echo "$# parameter/s remaining: $@"
>&2 echo "Looping through remaining parameter/s:"
# set input field separator to keep quoted parameters together
# for example, "my input" will remain as one input
IFS=$'\n'
for param in $@; do
   >&2 echo -e "\t${param}"
done

echo "user ${user_type} with user id ${user_id} has been created with position_id $position_id"
exit 0

e no terminal tentei executá-lo como:

bash test_bash --user_type abc --user_id a1b2 --country aud --dev_env uat --position_id aFWf

Estou recebendo apenas uma mensagem de ajuda como:

[--user_type abc --user_id a1b2 --country aud --dev_env uat --position_id aFWf] passed to script
getopt creates [ --user_type 'abc' --user_id 'a1b2' --country 'aus' --dev_env 'uat' --position_id 'aFWf' --]
Usage: test_bash]
   [ -a | --user_type input
   [ -b | --user_id input ]
   [ -c | --country input ] 
   [ -d | --dev_env input ]
   [ -e | --position_id input ]

Eu tentei atualizar/alterar algumas coisas como args=getopt com algumas outras opções. Mas os argumentos não estão sendo analisados ​​pelo script. Agradeço sua ajuda antecipadamente. Obrigado.

Então eu me deparei com um pouco de barreira, eu tenho uma opção no meu script que chama uma função que me permite especificar um arquivo/diretório e então eu quero analisar essa saída em uma ferramenta de menu (usando dmenu neste caso) para selecionar qual arquivo é o que eu quero especificamente e continuar trabalhando com essa seleção como uma variável no mesmo script. Isso funciona bem se for apenas um arquivo ou diretório, mas eu quero ser capaz de usar a opção várias vezes e então analisar toda essa saída de uma vez para dmenu. Aqui está um trecho

fileSelection () {
    if [ -d "${OPTARG}" ]; then find "${OPTARG}" -type f; fi;
    if [ -f "${OPTARG}" ]; then printf '%s\n' "${OPTARG}"; fi;
}

while getopts "f:" option; do
   case "${option}" in
       f) file="$(fileSelection|dmenu)";;
   esac
done

E como eu disse, isso funciona se eu fizer:

myscript -f file

ou

myscript -f directory

mas eu esperava poder fazer isso também:

myscript -f file1 -f file2

O problema é que, como a função é chamada consecutivamente, não consigo analisar a saída no dmenu dessa forma, porque ele não invoca o dmenu com as opções file1 e file2, mas primeiro com file1 e depois com file2. Espero que isso faça sentido.

Pode haver alguma solução realmente simples que eu esteja esquecendo, pensei em simplesmente escrever a saída em um arquivo e então analisar isso, o que pode funcionar, mas gostaria de evitar o pipe para arquivos, se possível. Também estou tentando mantê-lo compatível com POSIX, e apreciaria respostas que sigam isso.

Estou no Fedora, onde todos os shells pré-instalados aparentemente suportam bashisms: bash --posixdoes, e até mesmo sh. Ainda assim, quando usei esta função ,

pathprepend () {
    if [[ ":$PATH:" != *":$1:"* ]]; then
        PATH="$1${PATH:+":$PATH"}"
    fi
}

para adicionar um diretório a PATHpartir de ~/.profile, o Git não o pegou. Note que echo $PATHna sessão bash da qual eu estava usando o Git listou meu diretório, notei que só porque eu uso diff-highlight, symlinked naquele diretório, e depois que comecei a usar a pathprependfunção acima o Git reclamou que diff-highlightestava faltando. Depois de restaurar uma PATHconfiguração compatível com POSIX, ele voltou a funcionar normalmente.

Isso me deixou pensando o que os programas usam para ler seu ambiente. Cada um deles vem com seu próprio mecanismo para fazer isso? Eles deixam o trabalho para algum shell ou biblioteca do sistema?

Editar

@Bodo, é isso que eu costumava fazer: em ~/.profile,

pathprepend () {
    if [[ ":$PATH:" != *":$1:"* ]]; then
        PATH="$1${PATH:+":$PATH"}"
    fi
}

pathprepend "$HOME/.local/bin"

Por "compatível com POSIX" quero dizer sem nenhuma bashism. Isto é o que tenho agora em ~/.profile:

pathprepend () {
  case ":$PATH:" in
    *":$1:"*)
      :;;
    *)
      PATH="$1${PATH:+":$PATH"}";;
  esac
}

pathprepend "$HOME/.local/bin"

Em ambos os casos ~/.profileé proveniente de ~/.bash_profile, que contém

# Load the configuration for login sessions of any shell
if [[ -f "$HOME/.profile" ]]; then
  source "$HOME/.profile"
else
  echo >&2 "$HOME/.bash_profile: $HOME/.profile not found"
fi

# Load the configuration for interactive non-login Bash sessions
case "$-" in *i*)
  if [[ -f "$HOME/.bashrc" ]]; then
    source "$HOME/.bashrc"
  else
    echo >&2 "$HOME/.bash_profile: $HOME/.bashrc not found"
  fi;;
esac

Não fiz isso export PATHporque Gordon Davisson explica na resposta da qual copiei a função que " PATHjá deveria estar marcado como exportado, então não é necessário reexportar". Na verdade, ainda não fiz, exportmas com a caseversão de pathprependtudo funciona bem. A propósito, qual é o processo pai do processo Git, é o processo Bash do qual eu uso git?

Estou tentando fazer um caso de teste para um bug relacionado ao NFS, onde rm -rffalha com "Diretório não vazio" quando está vazio sempre que o inspeciono. No entanto, um script de teste simples não consegue reproduzir o erro, então tentei escrever um script que cria uma árvore de diretórios, preenche-a com arquivos e, em seguida, remove a árvore. Como suspeito que o problema esteja relacionado a algum cache de nome de arquivo, estou usando mktemppara criar nomes aleatórios como este:

#!/bin/sh
set -x
readonly LEVELS=6
readonly BASE_DIR=test-dir
DIR="$BASE_DIR"
for (( level=0; level < LEVELS; ++level ))
do
    if (( level > 0 )); then
        DIR="$(mktemp -p "$DIR")" || exit
    else
        mkdir "$DIR" || exit
    fi
    for (( i=0; i < 4; ++i ))
    do
        date > $(mktemp -p "$DIR") || exit
    done
    sleep 0.5
done
rm -rf "$BASE_DIR"

No entanto, o script falha de uma forma que não entendo, assim:

> ./test-script.sh
+ readonly LEVELS=6
+ LEVELS=6
+ readonly BASE_DIR=test-dir
+ BASE_DIR=test-dir
+ DIR=test-dir
+ (( level=0 ))
+ (( level < LEVELS ))
+ ((  level > 0  ))
+ mkdir test-dir
+ (( i=0 ))
+ (( i < 4 ))
+ date
++ mktemp -p test-dir
+ (( ++i  ))
+ (( i < 4 ))
+ date
++ mktemp -p test-dir
+ (( ++i  ))
+ (( i < 4 ))
+ date
++ mktemp -p test-dir
+ (( ++i  ))
+ (( i < 4 ))
+ date
++ mktemp -p test-dir
+ (( ++i  ))
+ (( i < 4 ))
+ sleep 0.5
+ (( ++level  ))
+ (( level < LEVELS ))
+ ((  level > 0  ))
++ mktemp -p test-dir
+ DIR=test-dir/tmp.iIbUu2ZDDN
+ (( i=0 ))
+ (( i < 4 ))
+ date
++ mktemp -p test-dir/tmp.iIbUu2ZDDN
mktemp: failed to create file via template ‘test-dir/tmp.iIbUu2ZDDN/tmp.XXXXXXXXXX’: Not a directory
./test-script.sh: line 15: $(mktemp -p "$DIR"): ambiguous redirect
+ exit

Então mktemp -p test-dirnão tem problemas, mas mktemp -p test-dir/tmp.iIbUu2ZDDNtem. Poderia ser um bug em mktemp, ou parece o bug que estou realmente procurando?

Estou ciente de que meu uso de mktempé um tanto atípico, mas enfim. O Binary vem de coreutils-8.32-150400.9.6.1.x86_64(SLES15 SP6).

Listando o diretório após a falha que vejo:

r> ll test-dir/
total 16
-rw------- 1 windl dvmed 32 Mar 13 12:03 tmp.gbslFgK2eD
-rw------- 1 windl dvmed  0 Mar 13 12:03 tmp.iIbUu2ZDDN
-rw------- 1 windl dvmed 32 Mar 13 12:03 tmp.lR5NM8zLtb
-rw------- 1 windl dvmed 32 Mar 13 12:03 tmp.p5Xcfqa3Xr
-rw------- 1 windl dvmed 32 Mar 13 12:03 tmp.YRELcRCk6G

Meu palpite é que o "redirecionamento ambíguo" ocorre devido à mktempfalha na criação de um nome de arquivo válido.

Estou automatizando o aumento de versão do meu projeto com este script bash:

#!/usr/bin/env bash

CHANGELOG="Changelog.md"
DEBIAN_CHANGELOG="debian/changelog"
UPSTREAM_VERSION=$(cat VERSION)

# Updating entries in rpm files

DEB_RELEASE_NOTES=$(awk '{print "  * " $0}' < RELEASE_NOTES)

echo "Adding new Debian changelog entry for version $UPSTREAM_VERSION."
dch -D unstable -m "$DEB_RELEASE_NOTES" --newversion "$UPSTREAM_VERSION-0debian1-unstable1"

# Prompt user to edit Debian changelog
$EDITOR_CHOICE "$DEBIAN_CHANGELOG"

echo "Version updated successfully: $UPSTREAM_VERSION"

O que ele faz é sincronizar e colocar a versão em ambos os pacotes rpm e debian. Mas este comando:

dch -D unstable -m "$DEB_RELEASE_NOTES" --newversion "$UPSTREAM_VERSION-0debian1-unstable1"

Isso me dá alguns problemas porque em alguns lugares no debian/changelog o seguinte:

mkdotenv (0.2.0-0debian1-unstable1) unstable; urgency=medium

  *   * 1. Split codebase into multiple files.   * 2. Use a seperate
    version file and define built version upon compile.   * 4. [BUGFIX]
    If input file is same as output file copy input file into a
    temporary one.   * 5. Improved Documentation

 -- Dimitrios Desyllas <[email protected]>  Mon, 10 Mar 2025 20:08:00 +0200

Enquanto o RELEASE_NOTESarquivo contém:

1. Split codebase into multiple files.
2. Use a seperate version file and define built version upon compile.
4. [BUGFIX] If input file is same as output file copy input file into a temporary one.
5. Improved Documentation

Você sabe por que todas as linhas estão presas como um único marcador???

mkfifo foo
printf %s\\n bar | tee foo &
tr -s '[:lower:]' '[:upper:]' <foo
wait
rm foo

Este é um script de shell POSIX funcional do que eu quero fazer:

• printf %s\\n baré simbólico para um programa externo que produz stdout
• tr -s '[:lower:]' '[:upper:]'é simbólico para outro comando que deve receber o stdout e fazer algo com ele
• teeduplica stdout para pipe nomeado foo

E a saída é como esperado:

bar
BAR

Agora eu gostaria de arrumar o código para que ele se torne external_program | my_function. Algo assim:

f() (
  mkfifo foo
  tee foo &
  tr -s '[:lower:]' '[:upper:]' <foo
  wait
  rm foo
)
printf %s\\n bar | f

Mas agora não há saída alguma.

Eu sei que isso set -ediz ao bash para sair do script em caso de erro. O problema é que eu tenho que resolver o erro, então deletar todos os passos anteriores do script enquanto mantenho todas as variáveis ​​antes de executá-lo novamente para continuar. Existe uma maneira de fazer o script simplesmente esperar pela entrada do usuário read -p "Continue? "em caso de erro? Se não, existe algo similar? Eu quero que o script pare em caso de erro, então continue novamente quando eu estiver pronto.

Estou tentando construir um wrapper para executar uma ferramenta várias vezes e, em seguida, concatenar alguns dos resultados. Gostaria de passar dois conjuntos de arquivos para meu script wrapper e, em seguida, executar a ferramenta para cada par de arquivos. Gostaria que ela se comportasse assim:

multitool.sh -a a*.txt -b b*.txt(expandindo os curingas para corresponder a todos os arquivos disponíveis)

Então multitool.sh, dentro do , executo a ferramenta em a1.txt b1.txt, a2.txt b1.txt, a1.txt b2.txt, a2.txt b2.txt, etc, com números variáveis ​​de arquivos a e b.

Eu segui este tutorial explicando os conceitos básicos de manipulação de opções e consegui usar getopspara manipular um -h, mas nada mais.

É aqui que estou agora:

#!/bin/bash


while getopts ":hpg:" option; do
    case $option in 
        h) # display help
            echo "-h to print this help and exit, -p is peak files, -g is bedgraph files."
            exit;;
        p) # get list of peak files to process
            l_peaks=$OPTARG;;
        g) # get list of bedgraph files to process
            l_bgraphs=$OPTARG;;
        \?) # Invalid option
            echo "Error! Invalid option!"
            echo "-h to print this help and exit, -p is peak files, -g is bedgraph files."
            exit;;
    esac
done

echo "$l_peaks"
echo "$l_bgraphs"

Estou trabalhando com uma equipe que não tem muita familiaridade com computadores, então, se eu puder manter o wrapper em uma execução simples de uma linha, seria melhor.

Como posso passar essas listas de arquivos como uma opção cada?