Ik gebruik curl op de commandoregel op Linux om HTTP-verzoeken uit te voeren. De antwoordbodies worden standaard geprint, wat prima is, maar ik kan op de man pagina niet zien hoe ik curl kan krijgen om de HTTP-statuscode van het antwoord af te drukken (404, 403 enz.). Is dit mogelijk?
Een meer specifieke manier om af te drukken alleen de HTTP-statuscode is iets in de trant van:
curl -s -o /dev/null -w "%{http_code}" http://www.example.org/
Een stuk eenvoudiger om mee te werken in scripts, omdat het geen parsing vereist :-)
De parameter -I kan worden toegevoegd om de prestaties van de responsbelasting te verbeteren. Deze parameter vraagt alleen om de status/koppen van de respons, zonder dat er een download-responsorgaan nodig is.
*Aanwijzing: * %{http_code} geeft de eerste regel van HTTP payload
weer, d.w.z.:
curl -s -o /dev/null -I -w "%{http_code}" http://www.example.org/
Als u de koptekst en het resultaat wilt zien kunt u gebruik maken van de verbose-optie:
curl -v http://www.example.org
curl --verbose http://www.example.org
De status verschijnt in de koptekst. Bijv.
< Date: Tue, 04 Nov 2014 19:12:59 GMT
< Content-Type: application/json; charset=utf-8
< Status: 422 Unprocessable Entity
U kunt de statuscode printen, naast alle headers, door het volgende te doen:
curl -i http://example.org
Het goede aan -i is dat het ook met -X POST werkt.
Als u de HTTP-statuscode in een variabele wilt vastleggen, maar toch de inhoud naar STDOUT wilt omleiden, moet u twee STDOUT’s aanmaken. U kunt dit doen met procesvervanging >() en opdracht vervanging $() .
Maak eerst een bestandsdescriptor 3 voor uw huidige proces’ STDOUT met exec 3>&1.
Gebruik vervolgens de optie -o van Curl om de reactie-inhoud om te leiden naar een tijdelijke {functieomschrijving} met behulp van de opdracht substitutie, en stuur binnen die opdracht de uitvoer terug naar uw huidige proces STDOUT bestandsdescriptor 3 met -o >(cat >&3).
Alles samenvoegen in bash 3.2.57(1)-release (standaard voor 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')
Noteer dat dit niet werkt in /bin/sh zoals SamK in de commentaren hieronder opmerkte .
Redefineer kruluitgang:
curl -sw '%{http_code}' http://example.org
Kan worden gebruikt bij elk type aanvraag.
Statuscode ONLY
[0]$ curl -LI http://www.example.org -o /dev/null -w '%{http_code}\n' -s
[0]$ 200
Allemaal tegoeden bij deze GIST
Dit is een pijnlijke curl --fail beperking. Vanaf man curl :
-f, –fail (HTTP) Fail stilletjes (geen enkele output) op serverfouten
Maar er is geen manier om zowel de non-zero return code en de response body in stdout te krijgen.
Gebaseerd op het antwoord van pvandenberk en deze andere zeer nuttige truc geleerd op SO , is hier een workaround :
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
}
Deze functie gedraagt zich precies als curl, maar geeft 127 (een retourcode die niet door curl wordt gebruikt) in het geval van een HTTP-code in het bereik [400, 600[.
Dit stuurt een verzoek naar url, krijgt alleen de eerste regel van het antwoord, splitst het op blokken en selecteert de tweede.
Het bevat de responscode
curl -I http://example.org 2>/dev/null | head -n 1 | cut -d$' ' -f2
Voor een POST-verzoek werkte het volgende:
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]'
Gebruik het volgende cURL commando en leid het naar grep als volgt:
$ curl -I -s -L http://example.com/v3/get_list | grep “HTTP/1.1”
Hier is wat elke vlag doet:
-I: Toon alleen antwoordkoppen -s: Stil - Toon geen voortgangsbalk -L: Volg Location: headers Hier is een link naar HTTP-statuscodes .
Run vanaf de opdrachtregel. Deze curl loopt in de stille modus, volgt eventuele omleidingen, krijgt de HTTP-headers. grep zal de HTTP-statuscode afdrukken naar de standaard uitvoer.
Hier is een krulcommando dat gebruik maakt van GET en dat de HTTP-code retourneert.
curl -so /dev/null -w '%{response_code}' http://www.example.org
Onthoud dat de onderstaande aanpak gebruik maakt van HEAD, wat sneller is, maar het werkt misschien niet goed met sommige web minder conforme HTTP-servers.
curl -I http://www.example.org
Een voorbeeld van het gebruik van de responscodes. Ik gebruik dit om Geolite databases alleen te downloaden als ze zijn veranderd (-z) & ook na omleidingen (-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
Het OP wil de statuscode weten. Vaak wil je bij het downloaden van een bestand ook een gevoel krijgen van de grootte ervan, dus ik gebruik curl eerst om de statuscode en de grootte van het bestand te tonen en sluit dan verbose en direct bestand af naar de plaats en naam die ik wil:
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
Dan wacht ik op de afwerking van curl
wait ${!}
voordat ik het volgende commando uitvoer. Het bovenstaande geeft bij gebruik in een script van vele commando’s zoals hierboven een mooi antwoord zoals:
http: 200 42824
http: 200 34728
http: 200 35452
Let op: -o in curl moet het volledige pad van het bestand + de naam van het bestand gevolgd worden. Dit laat u toe om bestanden op te slaan in een verstandige naamstructuur wanneer u d/l ze met curl opneemt. Merk ook op dat -s en -S samen gebruikt worden om de uitvoer stil te leggen, maar wel fouten vertonen. Merk ook op dat -R probeert de tijdstempel van het bestand in te stellen op die van het webbestand.
Mijn antwoord is gebaseerd op wat @pvandenberk oorspronkelijk suggereerde, maar daarnaast slaat het bestand ook daadwerkelijk ergens op, in plaats van alleen maar te verwijzen naar /dev/null.
Split output content naar stdout en HTTP statuscode naar stderr:
curl http://www.example.org -o >(cat >&1) -w "%{http_code}\n" 1>&2
Als alleen HTTP statuscode gewenst is om te stderr, --silent kan /dev/null worden gebruikt:
curl --silent http://www.example.org -o >(cat >&1) -w "%{http_code}\n" 1>&2
De gewenste stroom kan dan worden gekozen door ongewenste stroom om te leiden naar &007:
$ (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>
...
Aanwijzing dat voor de tweede omleiding om zich naar wens te gedragen, we het krulcommando in subshell moeten uitvoeren.