🏆Eindproject: Project: elke body lezen

Je server houdt verbindingen open, en je read_chunked decodeert chunks, maar je fetch leest nog steeds maar twee soorten body: geen na HEAD, en precies content-length bytes. Al het andere laat hem ValueError opwerpen. Dit project maakt de client af: fetch leest elke body volgens de regel uit les 2, en een nieuwe functie, fetch_many, stuurt meerdere verzoeken over één verbinding, zoals je server ze nu verwacht.

Wat de client moet doen

SERVICE_CONTRACT.md noemt de regels onder “The client in wire.py”. De twee nieuwe:

• fetch leest een body via content-length, via chunks of tot het sluiten, en leest geen body na HEAD of bij een 1xx-, 204- of 304-status. Hij weigert transfer-encoding samen met content-length, en elke transfer coding behalve chunked.

• fetch_many stuurt één verzoek tegelijk over één verbinding, vraagt bij het laatste om te sluiten, en werpt ConnectionError op als de server de verbinding te vroeg beëindigt.

Mijlpalen

Eerst read_until_close(reader, *, limit=MAX_BODY). Die geeft de bytes terug die al in de buffer staan en elke byte daarna, totdat recv b"" teruggeeft, en laat de buffer leeg achter. Ook een antwoord dat bij het sluiten eindigt, krijgt een limiet: werp ValueError op zodra de bytes limit overschrijden, voordat je om meer vraagt. Ongeveer zes regels.

Dan read_body(reader, method, headers, *, status=200). Herschrijf hem volgens de regel uit les 2, in die volgorde:

1. Geen body voor HEAD, voor een status onder 200, of voor 204 of 304: geef b"" terug zonder te lezen.

2. Met transfer-encoding: als content-length er ook is, werp dan ValueError op. De header moet precies één waarde bevatten, chunked in willekeurige hoofd- en kleine letters en met spaties eromheen toegestaan; al het andere, zoals gzip, chunked, werpt ValueError op, omdat deze client geen andere codering decodeert. Geef daarna terug wat read_chunked teruggeeft.

3. Zonder content-length: geef terug wat read_until_close teruggeeft.

4. Lees anders via content-length, zoals eerder.

De regel uit hoofdstuk 1 die een body zonder lengte weigerde, is verdwenen. De tests die bij dit hoofdstuk in tests/test_wire.py zijn meegekomen, verwachten hem niet meer, en de docstring bovenaan dat bestand zegt dat.

Dan fetch. Die geeft de status van het antwoord door: read_body(reader, method, response["headers"], status=response["status"]). Zonder die status zou een 304 met een content-length fetch laten wachten op bytes die nooit komen.

Voer de helper uit:

python pl_http.py bodies

Je fetch vraagt de kleine server uit les 3 om /length, /chunked en /close, elk over een eigen verbinding. Vóór je wijzigingen eindigt het chunked antwoord in raised ValueError: this client cannot measure a body sent with Transfer-Encoding yet. Erna eindigt elk van de drie rapporten in een body:

body: b'{}'  (2 bytes)
body: b'{"books": ["Kindred", "Caf\xc3\xa9"]}'  (31 bytes)
body: b'{"ends": "at the close"}'  (24 bytes)

Als laatste fetch_many(base_url, targets, *, connect=socket.create_connection, timeout=TIMEOUT). Die stuurt GET base_url + target voor elk doel, op volgorde, over één verbinding, en geeft een lijst records terug zoals het record dat fetch teruggeeft:

• Open de verbinding één keer, with connect((host, port), timeout=timeout) as sock:, met de host en poort van base_url (poort 80 als die er geen heeft), en maak één reader voor de hele verbinding. Bytes van het volgende antwoord kunnen in dezelfde recv aankomen als het einde van dit antwoord, en die wachten in de buffer van die reader.

• Bouw elk verzoek met build_request("GET", base_url + target, headers). Het laatste bevat de header Connection: close, zodat de server sluit zodra elk antwoord is aangekomen; de andere hebben geen Connection-header nodig.

• Stuur een verzoek, lees de kop en de body ervan, en stuur pas dan het volgende. Ze allemaal versturen voordat je leest, pipelining genoemd, laat deze cursus met rust.

• Als een antwoord vóór het laatste doel connection: close zegt, leest de server niets meer op deze verbinding. Werp dan meteen ConnectionError op, met een melding die beide getallen bevat, hoeveel doelen er zijn beantwoord en hoeveel het er waren, zoals the server closed the connection after 1 of 3 requests.

Ongeveer zestien regels. Voer het daarna uit tegen je eigen server:

python pl_http.py many

statuses: [200, 200, 200]
/me: b'{"user": null}'  (14 bytes)
serve() returned after 1 connection; the server is closed

pl_http drukt de drie verzoeken af als één client -> server-regel, omdat het alles wat een verbinding droeg samen toont. Het log van je server bevat drie verzoeken, en serve telde één verbinding.

Je tests

Je kunt tests toevoegen aan tests/test_wire.py, zoals in hoofdstuk 6. fakes.scripted_socket staat voor een zwijgende server die de verbinding open houdt als het script None bevat, en voor een gesloten server als het script gewoon ophoudt. Een antwoord zonder lengte wordt gelezen tot het sluiten, dus een test van zo’n antwoord eindigt zijn script zonder None:

def test_a_body_that_ends_at_the_close():
    sock = scripted_socket([b"HTTP/1.1 200 OK\r\n\r\nab", b"c"])
    response = wire.fetch("GET", ITEM_URL, connect=fake_connect(sock, []))
    assert response["body"] == b"abc"

Deze keer voert Check my work je tests één keer uit, zoals python -m pytest -x dat zou doen. Geen enkele mag falen, en geen enkele mag een echte verbinding openen. Voer ze eerst zelf uit:

python -m pytest -q

Wat er bewezen wordt, en hoe

Check my work koppelt je client aan je server zonder socket. De connect die hij aan fetch_many geeft, geeft een vervangende socket terug: wat je client verstuurt, gaat in dit proces door je eigen HTTP/1.1-handlerklasse, en wat je server schrijft, komt terug uit recv. Zodra elk antwoord is gelezen en de verbinding nog open is, werpt recv TimeoutError op, en dat betrapt een client die tot het sluiten leest en een serverantwoord zonder lengte. De runs bodies en many zijn er om naar te kijken en worden niet beoordeeld.

Druk daarna op Check my work. De framing, keep-alive en het afhandelen van het sluiten die requests op een verbinding voor je doet, heb je nu met de hand geschreven. Les 5 zet dezelfde bytes in TLS.