Vuoi arricciare per generare il codice di stato HTTP?

Sto usando curldalla riga di comando su Linux per inviare richieste HTTP. I corpi di risposta sono stampati sullo standard, il che va bene, ma dalla pagina man non riesco a vedere come ottenere l'arricciatura per stampare il codice di stato HTTP dalla risposta (404, 403 ecc.). È possibile?

Questo dovrebbe funzionare per te se il web server è in grado di rispondere alle richieste HEAD (questo non eseguirà a GET):

curl -I http://www.example.org

Inoltre, per consentire a cURL di seguire i reindirizzamenti (stati 3xx) aggiungere -L.

Un modo più specifico per stampare solo il codice di stato HTTP è qualcosa sulla falsariga di:

curl -s -o /dev/null -w "%{http_code}" http://www.example.org/

Molto più facile lavorare con gli script, in quanto non richiede alcun analisi :-)

È -Ipossibile aggiungere il parametro per migliorare le prestazioni del carico di risposta. Questo parametro richiede solo lo stato / le intestazioni della risposta, senza il corpo della risposta di download.

Nota: %{http_code} ritorna sulla prima riga del payload HTTP

vale a dire:

curl -s -o /dev/null -I -w "%{http_code}" http://www.example.org/

Se vuoi vedere l'intestazione e il risultato puoi usare l'opzione dettagliata:

curl -v http://www.example.org
curl --verbose http://www.example.org

Lo stato verrà visualizzato nell'intestazione. Per esempio

< Date: Tue, 04 Nov 2014 19:12:59 GMT
< Content-Type: application/json; charset=utf-8
< Status: 422 Unprocessable Entity

È possibile stampare il codice di stato, oltre a tutte le intestazioni, nel modo seguente:

curl -i http://example.org

La cosa positiva -iè che funziona anche con -X POST.

Se si desidera acquisire il codice di stato HTTP in una variabile, ma reindirizzare comunque il contenuto su STDOUT, è necessario creare due STDOUT. Puoi farlo con la sostituzione di processo> () e la sostituzione di comando $ () .

Innanzitutto, crea un descrittore di file 3per il processo corrente 'STDOUT con exec 3>&1.

Quindi, utilizzare l' -oopzione curl per reindirizzare il contenuto della risposta a un FIFO temporaneo utilizzando la sostituzione dei comandi, quindi all'interno di tale sostituzione dei comandi, reindirizzare l'output al descrittore di file STDOUT del processo corrente 3con -o >(cat >&3).

Mettendo tutto insieme in bash 3.2.57(1)-release(standard per macOS):

# creates a new file descriptor 3 that redirects to 1 (STDOUT)
exec 3>&1 
# Run curl in a separate command, capturing output of -w "%{http_code}" into HTTP_STATUS
# and sending the content to this command's STDOUT with -o >(cat >&3)
HTTP_STATUS=$(curl -w "%{http_code}" -o >(cat >&3) 'http://example.com')

Nota che questo non funziona /bin/shcome notato da SamK nei commenti qui sotto .

Ridefinisci output arricciatura:

curl -sw '%{http_code}' http://example.org

Può essere utilizzato con qualsiasi tipo di richiesta.

SOLO codice di stato

[0]$ curl -LI http://www.example.org -o /dev/null -w '%{http_code}\n' -s
[0]$ 200

Tutto il merito di questo GIST

Questa è una curl --faillimitazione dolorosa . Da man curl:

-f, --fail (HTTP) non riesce in modo silenzioso (nessun output) su errori del server

Ma non v'è alcun modo per ottenere sia il codice di ritorno diverso da zero e il corpo della risposta in stdout.

Sulla base della risposta di pvandenberk e di questo altro trucco molto utile appreso su SO , ecco una soluzione alternativa:

curl_with_error_code () {
    _curl_with_error_code "$@" | sed '$d'
}
_curl_with_error_code () {
    local curl_error_code http_code
    exec 17>&1
    http_code=$(curl --write-out '\n%{http_code}\n' "$@" | tee /dev/fd/17 | tail -n 1)
    curl_error_code=$?
    exec 17>&-
    if [ $curl_error_code -ne 0 ]; then
        return $curl_error_code
    fi
    if [ $http_code -ge 400 ] && [ $http_code -lt 600 ]; then
        echo "HTTP $http_code" >&2
        return 127
    fi
}

Questa funzione si comporta esattamente come curl, ma restituirà 127 (un codice di ritorno non utilizzato da curl) nel caso di un codice HTTP nell'intervallo [400, 600 [.

Questo invierà una richiesta di url, otterrà solo la prima riga della risposta, la dividerà su blocchi e selezionerà la seconda.

Contiene il codice di risposta

curl -I http://example.org 2>/dev/null | head -n 1 | cut -d$' ' -f2

Per una richiesta POST, ha funzionato:

curl -w 'RESP_CODE:%{response_code}' -s -X POST --data '{"asda":"asd"}' http://example.com --header "Content-Type:application/json"|grep -o  'RESP_CODE:[1-4][0-9][0-9]'

Utilizzare il seguente comando cURL e pipe per grep in questo modo:

$ curl -I -s -L http://example.com/v3/get_list | grep "HTTP / 1.1"

Ecco cosa fa ogni bandiera:

• -I: Mostra solo le intestazioni di risposta
• -s: Silenzioso: non mostra la barra di avanzamento
• -L: Segui le Location:intestazioni

Ecco un link ai codici di stato HTTP .

Esegui dalla riga di comando. Questo ricciolo viene eseguito in modalità silenziosa, segue tutti i reindirizzamenti, ottiene le intestazioni HTTP. grep stamperà il codice di stato HTTP sull'output standard.

curl -so -i /dev/null -w "%{http_code}"  http://www.any_example.com

Ciò restituirà le seguenti informazioni:

1. dati di risposta, se qualsiasi dato viene restituito dall'API come errore
2. codice di stato

Ecco qualche comando di arricciatura che sta utilizzando GETe che restituisce il codice HTTP.

curl -so /dev/null -w '%{response_code}' http://www.example.org

Ricorda che sta usando l'approccio seguente HEAD, che è più veloce ma potrebbe non funzionare bene con alcuni server HTTP meno conformi al Web.

 curl -I http://www.example.org

Un esempio di come utilizzare i codici di risposta. Lo uso per scaricare nuovamente i database Geolite solo se sono stati modificati ( -z) e anche per i seguenti reindirizzamenti ( -L):

url=http://example.com/file.gz
file=$(basename $url)

response=$(curl -L -s -o $file -z $file $url -w "%{http_code}")

case "$response" in
        200) do_something ;;
        301) do_something ;;
        304) printf "Received: HTTP $response (file unchanged) ==> $url\n" ;;
        404) printf "Received: HTTP $response (file not found) ==> $url\n" ;;
          *) printf "Received: HTTP $response ==> $url\n" ;;
esac

L'OP vuole conoscere il codice di stato. Spesso quando scarichi un file vuoi anche avere un'idea delle sue dimensioni, quindi uso prima l'arricciatura per mostrare il codice di stato e le dimensioni del file, quindi spengo il file dettagliato e diretto nel luogo e nel nome che desidero:

curl -R -s -S -w  "\nhttp: %{http_code} %{size_download}\n" -o /Users/myfiles/the_local_name.html http://archive.onweb.com/the_online_name.html

Quindi aspetto la finitura del ricciolo

wait ${!}

prima di eseguire il comando successivo. Quanto sopra usato in uno script con molti comandi come sopra fornisce una buona risposta come:

http: 200 42824

http: 200 34728

http: 200 35452

Si noti che -o in curl deve essere seguito dal percorso completo del file + nome del file. Ciò consente quindi di salvare i file in una struttura di nomi sensata quando li d / l con arricciatura. Si noti inoltre che -s e -S usati insieme disattivano l'output ma mostrano errori. Si noti inoltre che -R tenta di impostare il timestamp del file su quello del file web.

La mia risposta si basa su ciò che inizialmente suggeriva @pvandenberk, ma in realtà salva il file da qualche parte, invece di limitarsi a dirigere a / dev / null.

Dividi il contenuto di output in stdoute il codice di stato HTTP in stderr:

curl http://www.example.org -o >(cat >&1) -w "%{http_code}\n" 1>&2

Se si desidera solo il codice di stato HTTP per stderr, è --silentpossibile utilizzare:

curl --silent http://www.example.org -o >(cat >&1) -w "%{http_code}\n" 1>&2

Lo stream desiderato può quindi essere scelto reindirizzando uno indesiderato a /dev/null:

$ (curl --silent http://www.example.org -o >(cat >&1) -w "%{http_code}" 1>&2) 1>/dev/null
200
$ (curl --silent http://www.example.org -o >(cat >&1) -w "%{http_code}" 1>&2) 2>/dev/null
<!doctype html>
...

Si noti che affinché il secondo reindirizzamento si comporti come desiderato, è necessario eseguire il comando curl in subshell.