Perguntas[bash](coding)

No bash, estou tentando encontrar diretórios que contenham um arquivo específico; no entanto, esses diretórios estão em níveis diferentes, por exemplo, se eu estiver procurando por dir03/myfile.txt:

dir01/dir02/dir03/myfile.txt
dir01/dir03/ ##no target file in it
dir01/dir04/dir05/dir03/myfile.txt
dir01/dir04/dir05/dir06/myfile.txt ##I do not want this

Eu poderia fazer:

find ./dir01 -type -d -iname "dir03"

Mas então eu obteria todos os diretórios, mesmo aqueles sem o arquivo de destino

Se eu fizer isso:

find ./dir01/*/dir03 -iname "myfile.txt" 

Eu não veria "dir01/dir04/dir05/dir03/myfile.txt"

Isso não funciona:

find ./dir01 -iname "dir03/myfile.txt"

##find: warning: Unix filenames usually don't contain slashes (though pathnames do).  
That means that '-iname ‘dir03/myfile.txt’' will probably evaluate to false all the time on this system.  You might find the '-wholename' test more useful, or perhaps '-samefile'.  Alternatively, if you are using GNU grep, you could use 'find ... -print0 | grep -FzZ ‘dir03/myfile.txt’'

Eu posso fazer isso:

find ./dir01 -iname "myfile.txt" -print0 | grep -FzZ 'dir03' | sed "s/myfile\.txt/\n/g"

Ele encontra todas as correspondências onde myfile.txt está e obtém apenas as contidas no diretório de destino; depois disso, divido os resultados com uma nova linha (a linha acima fornece os resultados concatenados, por exemplo, ./dir01/dir02/dir03/myfile.txt./dir01/dir04/dir05/dir03/myfile.txt mas pode tornar a pesquisa mais genérica e longa caso eu tenha uma estrutura de subdiretório complexa. Eu queria saber se havia uma solução mais fácil para dizer ao find para encontrar "dir03/myfile.txt" em qualquer nível

Observe que os nomes dos diretórios são apenas para fins de exemplo, eles não compartilham o mesmo prefixo.

Editar : Acho que eu poderia fazer

find ./dir01 -iname "myfile.txt" > myres0.txt
grep 'dir03' myres0.txt > myres1.txt

Considerando que estou procurando por vários diretórios parentais e não apenas dir03, ele faria apenas uma pesquisa, então eu poderia usar um arquivo txt com meus diretórios de destino e fazer:

grep -f mytargetDirs.txt myres0.txt > myres1.txt

Ainda estou me perguntando se existe uma maneira melhor.

Dado:

MY_JSON=$(cat <<EOF
{
  "schema": "my.schema",
  "properties": [
    {
      "type": "new.data",
      "value": {
        "labels": {
          "ofasd.io/arch.amd64": "supported",
          "ofasd.io/arch.arm64": "supported",
          "ofasd.io/arch.ppc64le": "supported",
          "ofasd.io/arch.s390x": "unsupported"
        }
      }
    }
  ]
}
EOF
)

Estou tentando filtrar apenas arquiteturas "compatíveis":

arches=$(echo "$MY_JSON" | tr -d '\000-\031' | jq -r '
.properties[] 
| select(.type == "new.data") 
| .value.labels 
| to_entries 
| map(select(.key | test("^ofasd\\.io/arch\\.") and .value == "supported")) 
| map(.key | sub("^ofasd\\.io/arch\\."; "")) 
| join("\n")')

Saída esperada:

amd64
arm64
ppc64le

Produção real:

jq: error (at <stdin>:0): Cannot index string with string "value"

Alguém poderia me ajudar a entender o que estou fazendo errado? Parece que o problema é que a filtragem ofasd.io/arch.* não está funcionando. Quando executo:

echo "$MY_JSON" | jq -r '
.properties[] 
| select(.type == "new.data") 
| .value.labels 
| to_entries 
| map(select(.key | test("^ofasd.io/arch\\.") and .value == "supported"))'

Eu entendo:

echo "$MY_JSON" | jq -r '' failed with status 5

Eu escrevi um bashscript que:

• obtém a última Githubexecução de CI/CD
• verifica o resumo dos artefatos baixados
• gera um processo para baixar e extrair cada artefato (em paralelo) se o resumo tiver sido alterado
• aguarda até que o processo de download e extração seja concluído e executa novamente o script

Tenho um problema - o script gera as tarefas paralelas sem problemas, mas faz isso a cada 10 segundos. Por algum motivo, isso waitnão está sendo respeitado.

Por que isso acontece e como posso consertar?

Este é meu script:

#!/bin/bash

# GitHub repository details
REPO="RiceKX/Hydra"            # Format: owner/repo, e.g., "octocat/Hello-World"
BRANCH="development"           # The branch you want to check for the latest build
GITHUB_TOKEN="${GITHUB_TOKEN:-$(cat /path/to/your/token)}"  # GitHub token with necessary permissions
GITHUB_API="https://api.github.com"
ARTIFACTS_DIR="latest_dev_build"    # Directory to store downloaded artifacts

# Ensure the artifacts directory exists
mkdir -p "$ARTIFACTS_DIR"

# Run the script in an infinite loop
while true; do
    # Check if repository, branch, and GitHub token are provided
    if [ -z "$REPO" ] || [ -z "$BRANCH" ] || [ -z "$GITHUB_TOKEN" ]; then
      echo "Please set the repository, branch, and GitHub token in the script."
      exit 1
    fi

    # Step 1: Fetch the latest successful run for the specified branch
    echo "Fetching the latest successful build for branch '$BRANCH'..."

    RUN_ID=$(curl -s \
      -H "Authorization: token $GITHUB_TOKEN" \
      "$GITHUB_API/repos/$REPO/actions/runs?branch=$BRANCH&status=success&per_page=1" | \
      jq -r '.workflow_runs[0].id')

    if [ "$RUN_ID" == "null" ] || [ -z "$RUN_ID" ]; then
      echo "No successful builds found for branch '$BRANCH'."
      exit 1
    fi

    echo "Latest successful run ID: $RUN_ID"

    # Step 2: Fetch the artifacts associated with this run
    echo "Fetching artifacts for the latest run..."

    ARTIFACTS=$(curl -s \
      -H "Authorization: token $GITHUB_TOKEN" \
      "$GITHUB_API/repos/$REPO/actions/runs/$RUN_ID/artifacts")

    # Check if we successfully got the artifacts
    if [ -z "$ARTIFACTS" ] || [ "$(echo "$ARTIFACTS" | jq '.artifacts | length')" -eq 0 ]; then
      echo "No artifacts found for this run."
      exit 1
    fi

    # Step 3: Extract artifact details and download them in parallel
    PIDS=()  # Store background process PIDs to wait for them later
    echo "$ARTIFACTS" | jq -r '.artifacts[] | "\(.name) \(.archive_download_url) \(.digest)"' | \
    while read ARTIFACT_NAME ARTIFACT_DOWNLOAD_URL ARTIFACT_DIGEST; do
        if [ -z "$ARTIFACT_NAME" ] || [ -z "$ARTIFACT_DOWNLOAD_URL" ] || [ -z "$ARTIFACT_DIGEST" ]; then
          echo "Error: Artifact name, download URL, or digest missing for artifact."
          continue
        fi

        ARTIFACT_PATH="$ARTIFACTS_DIR/$ARTIFACT_NAME.zip"

        # Check if the artifact already exists
        if [ -f "$ARTIFACT_PATH" ]; then
            # Calculate the local digest of the downloaded artifact
            LOCAL_DIGEST=$(sha256sum "$ARTIFACT_PATH" | cut -d' ' -f1)

            # If the local digest matches the GitHub digest, skip downloading
            if [ "$LOCAL_DIGEST" == "$ARTIFACT_DIGEST" ]; then
                echo "Artifact $ARTIFACT_NAME is already up to date (digest matches), skipping download."
                continue
            else
                echo "Artifact $ARTIFACT_NAME exists but the digest does not match. Re-downloading..."
            fi
        fi

        # Download and extract each artifact in parallel
        (
            echo "Downloading and extracting artifact: $ARTIFACT_NAME from $ARTIFACT_DOWNLOAD_URL"

            curl -L -o "$ARTIFACT_PATH" \
              -H "Authorization: token $GITHUB_TOKEN" \
              "$ARTIFACT_DOWNLOAD_URL"
            
            if [ $? -eq 0 ]; then
                echo "Artifact $ARTIFACT_NAME downloaded successfully."

                # Extract the downloaded artifact
                unzip -o "$ARTIFACT_PATH" -d "$HOME"
                echo "Artifact $ARTIFACT_NAME extracted to $HOME."
            else
                echo "Failed to download $ARTIFACT_NAME."
            fi
        ) &  # Run this process in the background

        PIDS+=($!)
    done

    # Wait for all background processes to finish before continuing
    echo "Waiting for background processes to finish..."
    for PID in "${PIDS[@]}"; do
        wait "$PID"
    done

    echo "All artifacts downloaded and extracted successfully."

    # Sleep for 10 seconds before running the script again
    echo "Waiting for 10 seconds before checking again..."
    sleep 10
done

Dada uma stringPlease help me do my homework !!!

Gostaria de analisá-lo Please help me do my homeworkusando o bash.

O que eu tentei é

str="Please help me do my homework !!!"
printf "${str: -4:100}"

que eu obtenho !!!. Acho que ${str: -4} significa que começa no 4º caractere do último.

Tenho o seguinte arquivo com tabulações como separadores de campo:

header1 header2 header3 header4 header5
1field1 1field2 1field3 1field4 1field5
2field1 2field2 2field3 2field4 2field5
3field1 3field2 3field3 3field4 3field5
4field1 4field2 4field3 4field4 4field5

e gostaria de gerar cada linha em um novo arquivo (pulando a primeira linha). Cada novo arquivo será nomeado a partir do 1º e 5º campos com um separador de sublinhado. O arquivo da linha 1 (2 tecnicamente) seria nomeado "1field1_1field5.txt" e conteria todos os campos dessa linha e assim por diante. Eu tenho o seguinte comando awk que gera os nomes de arquivo corretos para a saída padrão

awk -v FS='\t' -v OFS='_' 'NR>1 {print ($1,$5 ".txt") }'

mas quando tento gerar o texto em nomes de arquivo

awk -v FS='\t' -v OFS='_' 'NR>1 {print > ($1,$5 ".txt") }'

Recebo o seguinte erro

awk: cmd. line:1: NR>1 { print > ($1,$5 ".txt") }
awk: cmd. line:1:                               ^ syntax error

Copiei e colei de 10 outros artigos diferentes para chegar até aqui, mas não consigo entender como minha formatação está errada.

Tenho um script de shell iniciando um contêiner docker. Antes de iniciar o contêiner, ele inicia um loop em segundo plano imprimindo algumas linhas no terminal. Percebi que essas linhas impressas não retornam o cursor para o início da linha. O que descobri: isso acontece apenas durante o tempo de vida do contêiner. Veja o exemplo mínimo:

#!/usr/bin/env bash

cleanup() {
  kill "${BACKGROUND_PROCESS}"
}
trap cleanup EXIT

backgroundLoop() {
  while true; do
    echo .
    sleep 1
  done
}

backgroundLoop &
BACKGROUND_PROCESS=$!

sleep 2
echo Starting docker

docker run --rm -it alpine sleep 5

echo Docker has finished
sleep 2

cleanup

A saída é:

.
.
Starting docker
.
.
 .
  .
   .
    .
     Docker has finished
.
.

Alguém pode explicar por que isso acontece? Parece estar relacionado a esta pergunta , presumo que o docker reconfigure o TTY atual e o restaure depois. Isso está correto?

Remover -tda chamada docker realmente corrige o problema, o que parece respaldar minha teoria. No entanto, preciso do TTY interativo para meu caso de uso real.

Como posso alterar meu código para que todas as linhas de saída sejam impressas com retornos de carro corretos?

ATUALIZAR :

Obtive uma resposta para essa pergunta que resolve o problema do meu exemplo mínimo postado acima, chamando stty -onocro contêiner docker antes do comando real.

Meu cenário do mundo real, no entanto, usa uma imagem docker personalizada com um script bash como ponto de entrada, então não posso passar comandos como argumentos. Exemplo mínimo do script entrypoint entrypoint.sh:

#!/usr/bin/env sh

sleep 5

Em seguida, substitua a chamada do docker no script de teste

docker run --rm -it alpine sleep 5

com

docker run --rm -it -v ./entrypoint.sh:/entrypoint.sh --entrypoint /entrypoint.sh alpine

A saída é a mesma, mas a correção proposta não funciona neste caso. Alguma ideia de como aplicar a correção a este ambiente ligeiramente diferente?

Eu uso basho MINGW64 no Windows 10. Eu mesmo compilei uma versão dele wcalcalguns anos atrás, que costumava funcionar bem para mim - mas recentemente notei que ele quebra completamente a coloração ANSI no terminal:

... ou seja, em vez de receber o seguinte prompt com cores:

user@DESKTOP-PC 2025-02-25|03:41:27 MINGW64 ~
$ 

... Recebo essa confusão de caracteres, em vez do prompt (depois de tentar executar wcalc 2+2):

←[?2004h←]0;~
←[32muser@DESKTOP-PC ←[36m2025-02-25|03:41:56←[0m ←[35mMINGW64←[0m ←[33m~←[0m
←[1m$←[0m

Você pode notar na captura de tela que executar o resetcomando (que geralmente resolve todos os meus problemas de comportamento do terminal) não ajuda a restaurar o comportamento correto.

Alguém saberia qual comando eu poderia usar para restaurar o comportamento correto dos caracteres de cor ANSI do terminal, quando eu chegar a esse estado (atualmente não tenho outra opção a não ser fechar e reiniciar o terminal)

EDIT: Descobri que o problema era que havia uma DLL antiga msys-2.0.dlle algumas outras na mesma pasta wcalc.exe; essas DLLs antigas aparentemente entravam em conflito com as DLLs mais novas - então a solução geral para mim foi simplesmente remover as DLLs antigas da wcalcpasta e copiar as novas DLLs do MSYS2 /binpara lá.

No entanto, ainda seria bom saber se é possível se recuperar da situação confusa de cores do terminal, conforme descrito acima, com um comando; então espero que alguém possa responder a isso.

Arquivo de entrada.

1  30.01.2025     30.01.2025           telefontelefon       -1.00           87.39   87.39   30.01.2025
2  31.01.2025     31.01.2025           telefontelefon       -3.46           32.14   32.14   31.01.2025
3  01.02.2025     
4  02.02.2025     
5  03.02.2025     03.02.2025           telefontelefon       -10.00          71.14   71.14   03.02.2025
6  04.02.2025     04.02.2025           telefontelefon       1609.00         80.14   80.14   04.02.2025
7  05.02.2025     05.02.2025           telefontelefon       11.00           22.14   22.14   05.02.2025
8  06.02.2025 
9  07.02.2025     05.02.2025           telefontelefon       14.00           22.14   55.14   05.02.2025

Quero obter um arquivo de saída.

1  30.01.2025     30.01.2025           telefontelefon       -1.00           87.39   87.39   30.01.2025
2  31.01.2025     31.01.2025           telefontelefon       -3.46           32.14   32.14   31.01.2025
3  01.02.2025                                                                       32.14 
4  02.02.2025                                                                       32.14
5  03.02.2025     03.02.2025           telefontelefon       -10.00          71.14   71.14   03.02.2025
6  04.02.2025     04.02.2025           telefontelefon       1609.00         80.14   80.14   04.02.2025
7  05.02.2025     05.02.2025           telefontelefon       11.00           22.14   22.14   05.02.2025
8  06.02.2025                                                                       22.14
9  07.02.2025     05.02.2025           telefontelefon       14.00           22.14   55.14   05.02.2025

Para uma coluna usei este comando.

awk 'NF{last=$0;print;next} {$0=last}1'  plik

É assim que ficam os espaços entre as colunas.

    $ awk '{gsub(" ","-")};1' plik 
1--30.01.2025-----30.01.2025-----------telefontelefon--------1.00-----------87.39---87.39---30.01.2025
2--31.01.2025-----31.01.2025-----------telefontelefon--------3.46-----------32.14---32.14---31.01.2025
3--01.02.2025-----
4--02.02.2025-----
5--03.02.2025-----03.02.2025-----------telefontelefon--------10.00----------71.14---71.14---03.02.2025
6--04.02.2025-----04.02.2025-----------telefontelefon-------1609.00---------80.14---80.14---04.02.2025
7--05.02.2025-----05.02.2025-----------telefontelefon-------11.00-----------22.14---22.14---05.02.2025
8--06.02.2025-
9--07.02.2025-----05.02.2025-----------telefontelefon-------14.00-----------22.14---55.14---05.02.2025
pic@pi

file1, que contém uma única string por linha. Quero verificar se cada string existe na segunda coluna de file2. file2 contém duas strings separadas por espaços simples por linha, mas algumas linhas podem ter espaços iniciais antes da primeira coluna.

Quero usar apenas grep e/ou cut para executar a correspondência e gerar linhas correspondentes de file2 para newFile.txt, garantindo a correspondência de palavras inteiras (-w).

Eu tentei

grep -wF -f file1 file2 > newFile.txt 

mas devido ao tamanho do arquivo o terminal roda infinitamente.

Eu também tentei

grep -wF -f <(cut -d ' ' -f 2 file2) | grep -wF -f - file2 > newFile.txt 

Isso só funciona para algumas linhas no arquivo2 porque algumas linhas têm vários espaços antes das duas strings, embora essas strings sejam separadas apenas por um único espaço.

Arquivo1:

 aaa
 bbb
 ccc

Arquivo2:

 a aaa (should match) 
     b bbb (should match and does but the former spaces throws off cut -d, resulting in incomplete output of line in the newFile.txt)
 c cc (should not match) 

Pergunta: Como posso extrair e combinar eficientemente palavras inteiras na segunda coluna de file2.txt, enquanto lido com espaços iniciais inconsistentes? Prefiro usar grep e/ou cut, mas estou aberto a pequenas modificações.

Em bash, sabe-se que set -eele é ignorado em substituições de comando (a menos que inherit_errexitesteja habilitado).

Entretanto, quando falsecommand é executado em substituição de comando, set -eNÃO é ignorado. Por quê?

Código:

set -e
shopt | grep inherit_errexit

echo hello

a=$(false)

echo world

Esperado:

inherit_errexit off
hello
world

Real:

inherit_errexit off
hello

shell returned 1