Comment envoyer de la réponse HTTP avec Python à l'aide de prise à la bibliothèque?

J'ai une question très simple serveur web écrit en Python. Il écoute sur le port 13000, comment puis-je faire livrer un simple "Hello World" page web si http://localhost:13000 est ouvert dans le navigateur?

Droite il y a mon code:

# set up socket and connection
while True:
    sock, addr = servSock.accept()
    # WHAT GOES HERE?
    sock.close()

Comme vous pouvez le voir, je ne suis pas sûr de savoir exactement comment envoyer la page web?

Je n'ai qu'à utiliser le socket bibliothèque.

EDIT: Le problème n'est pas que je ne sais pas comment formuler la réponse HTTP, je ne sais pas comment le faire afficher dans mon navigateur! Il continue de tourner et le chargement.

InformationsquelleAutor antonpug | 2012-04-11

Mis à jour en fonction à la question du changement

Éventuellement, il continue de tourner à cause d'une combinaison de absense de Content-Length et Connection en-têtes, le navigateur peut présumer qu'il est Connection: keep-alive, alors qu'il continue de recevoir des données à partir de votre serveur pour toujours. Essayez d'envoyer Connection: close, et passer réelle Content-Length pour voir si cela aide.

Ne pas ce faire ce que vous attendez? 🙂

#!/usr/bin/env python
# coding: utf8
import socket
MAX_PACKET = 32768
def recv_all(sock):
r'''Receive everything from `sock`, until timeout occurs, meaning sender
is exhausted, return result as string.'''
# dirty hack to simplify this stuff - you should really use zero timeout,
# deal with async socket and implement finite automata to handle incoming data
prev_timeout = sock.gettimeout()
try:
sock.settimeout(0.01)
rdata = []
while True:
try:
rdata.append(sock.recv(MAX_PACKET))
except socket.timeout:
return ''.join(rdata)
# unreachable
finally:
sock.settimeout(prev_timeout)
def normalize_line_endings(s):
r'''Convert string containing various line endings like \n, \r or \r\n,
to uniform \n.'''
return ''.join((line + '\n') for line in s.splitlines())
def run():
r'''Main loop'''
# Create TCP socket listening on 10000 port for all connections, 
# with connection queue of length 1
server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, \
socket.IPPROTO_TCP)
server_sock.bind(('0.0.0.0', 13000))
server_sock.listen(1)
while True:
# accept connection
client_sock, client_addr = server_sock.accept()
# headers and body are divided with \n\n (or \r\n\r\n - that's why we
# normalize endings). In real application usage, you should handle 
# all variations of line endings not to screw request body
request = normalize_line_endings(recv_all(client_sock)) # hack again
request_head, request_body = request.split('\n\n', 1)
# first line is request headline, and others are headers
request_head = request_head.splitlines()
request_headline = request_head[0]
# headers have their name up to first ': '. In real world uses, they
# could duplicate, and dict drops duplicates by default, so
# be aware of this.
request_headers = dict(x.split(': ', 1) for x in request_head[1:])
# headline has form of "POST /can/i/haz/requests HTTP/1.0"
request_method, request_uri, request_proto = request_headline.split(' ', 3)
response_body = [
'<html><body><h1>Hello, world!</h1>',
'<p>This page is in location %(request_uri)r, was requested ' % locals(),
'using %(request_method)r, and with %(request_proto)r.</p>' % locals(),
'<p>Request body is %(request_body)r</p>' % locals(),
'<p>Actual set of headers received:</p>',
'<ul>',
]
for request_header_name, request_header_value in request_headers.iteritems():
response_body.append('<li><b>%r</b> == %r</li>' % (request_header_name, \
request_header_value))
response_body.append('</ul></body></html>')
response_body_raw = ''.join(response_body)
# Clearly state that connection will be closed after this response,
# and specify length of response body
response_headers = {
'Content-Type': 'text/html; encoding=utf8',
'Content-Length': len(response_body_raw),
'Connection': 'close',
}
response_headers_raw = ''.join('%s: %s\n' % (k, v) for k, v in \
response_headers.iteritems())
# Reply as HTTP/1.1 server, saying "HTTP OK" (code 200).
response_proto = 'HTTP/1.1'
response_status = '200'
response_status_text = 'OK' # this can be random
# sending all this stuff
client_sock.send('%s %s %s' % (response_proto, response_status, \
response_status_text))
client_sock.send(response_headers_raw)
client_sock.send('\n') # to separate headers from body
client_sock.send(response_body_raw)
# and closing connection, as we stated before
client_sock.close()
run()

Pour une description plus détaillée, veuillez consulter description du protocole HTTP.

Oui mais...le navigateur continue de "spinning" et rien ne s'affiche?
J'ai mis à jour l'exemple de code pour un travail garanti à 100%:) j'espère que vous trouverez les principes de base de l'en-tête de la manipulation utile, mais je vous recommande de ne pas compter sur ce genre de code et de mettre en œuvre complète de la requête HTTP de l'analyseur.
eh bien, vous avez fait une jolie réponse complète... mais je pense que la raison pour laquelle il était toujours en rotation (jusqu'au délai d'attente), c'est qu'il était en attente d'une double "\n". Mais au moins, votre code d'exemple est un bon extrait de l'avoir sous le crochet, juste au cas où 😉

InformationsquelleAutor toriningen

5

Renvoyer quelque chose comme:
```
HTTP/1.1 200 OK
Date: Wed, 11 Apr 2012 21:29:04 GMT
Server: Python/6.6.6 (custom)
Content-Type: text/html
```
Le code html. Assurez-vous qu'il est un saut de ligne après le Type de Contenu de la ligne et avant le html.

InformationsquelleAutor Albert Veli
3

ou, si vous ne voulez pas de se rappeler le protocole complet, vous pouvez le retrouver en utilisant :
```
 % nc stackoverflow.com 80
GET / HTTP/1.1
Host: stackoverflow.com
HTTP/1.1 200 OK
Cache-Control: public, max-age=60
Content-Type: text/html; charset=utf-8
Expires: Wed, 11 Apr 2012 21:33:49 GMT
Last-Modified: Wed, 11 Apr 2012 21:32:49 GMT
Vary: *
Date: Wed, 11 Apr 2012 21:32:49 GMT
Content-Length: 206008
[...]
% 
```
bien, vous ne préfèrent généralement un site qui est moins verbeux (généralement d'un fichier statique) que stackoverflow 😉

Les exigences minimales (vous trouverez sur la réponse) est :
```
sock.send(r'''HTTP/1.0 200 OK
Content-Type: text/plain
Hello, world!
''')
```
deux rendements sont obligatoires pour le serveur pour obtenir la réponse, sinon le navigateur attend indéfiniment, pour les en-têtes

Mais pour imiter le comportement d'un serveur web, n'oubliez pas d'envoyer votre réponse seulement après que le navigateur vous envoie quelques données, suivies par deux retours chariot, vous pouvez généralement obtenir ce qu'il envoie à l'aide de :
```
 % nc -kl localhost 13000
GET / HTTP/1.1
Host: localhost:13000
User-Agent: Mozilla/5.0...
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip, deflate
DNT: 1
Connection: keep-alive
%
```
de sorte que vous pouvez améliorer vos routines de test

InformationsquelleAutor zmo

# set up socket and connection
while True:
sock, addr = servSock.accept()
sock.send("HTTP/1.1 200 OK\n"
+"Content-Type: text/html\n"
+"\n" # Important!
+"<html><body>Hello World</body></html>\n");
sock.close()

InformationsquelleAutor Luky

1

Vous pourriez voulez extraire des objets web http://www.webob.org/

C'est un simple léger de projet pour la création de http compatibles les demandes et les réponses. Vous pouvez faire à peu près n'importe quoi avec vous les demandes et la réponse des objets ... Ou simplement déléguer le levage lourd pour WebObjects

Échantillon
```
>>> from webob import Response
>>> res = Response()
>>> res.status
'200 OK'
>>> res.headerlist
[('Content-Type', 'text/html; charset=UTF-8'), ('Content-Length', '0')]
>>> res.body
''
```
InformationsquelleAutor user590028

J'ai pris un à la réponse précédente et modifié le code pour Python3 utf-8 et d'octets codage. Merci pour la réponse originale à cette question, il a aidé beaucoup.

import socket
MAX_PACKET = 32768
def recv_all(sock):
r'''Receive everything from `sock`, until timeout occurs, meaning sender
is exhausted, return result as string.'''
# dirty hack to simplify this stuff - you should really use zero timeout,
# deal with async socket and implement finite automata to handle incoming data
prev_timeout = sock.gettimeout()
try:
sock.settimeout(0.1)
rdata = []
while True:
try:
# Gotta watch for the bytes and utf-8 encoding in Py3
rdata.append(sock.recv(MAX_PACKET).decode('utf-8')) 
except socket.timeout:
return ''.join(rdata)
# unreachable
finally:
sock.settimeout(prev_timeout)
def normalize_line_endings(s):
r'''Convert string containing various line endings like \n, \r or \r\n,
to uniform \n.'''
test = s.splitlines()
return ''.join((line + '\n') for line in s.splitlines())
def run():
r'''Main loop'''
# Create TCP socket listening on 10000 port for all connections,
# with connection queue of length 1
server_sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM,
socket.IPPROTO_TCP)
#Added the port 13001 for debuging purposes 
try:
server_sock.bind(('0.0.0.0', 13000))
print('PORT 13000')
except:
server_sock.bind(('0.0.0.0', 13001))
print('PORT 13001')
# except:
#     server_sock.bind(('0.0.0.0', 13002))
#     print('PORT 13002')
server_sock.listen(1)
while True:
# accept connection
try:
client_sock, client_addr = server_sock.accept()
# headers and body are divided with \n\n (or \r\n\r\n - that's why we
# normalize endings). In real application usage, you should handle
# all variations of line endings not to screw request body
request = normalize_line_endings(recv_all(client_sock)) # hack again
request_head, request_body = request.split('\n\n', 1)
# first line is request headline, and others are headers
request_head = request_head.splitlines()
request_headline = request_head[0]
# headers have their name up to first ': '. In real world uses, they
# could duplicate, and dict drops duplicates by default, so
# be aware of this.
request_headers = dict(x.split(': ', 1) for x in request_head[1:])
# headline has form of "POST /can/i/haz/requests HTTP/1.0"
request_method, request_uri, request_proto = request_headline.split(' ', 3)
response_body = [
'<html><body><h1 style="color:red">Hello, world!</h1>',
'<p>This page is in location %(request_uri)r, was requested ' % locals(),
'using %(request_method)r, and with %(request_proto)r.</p>' % locals(),
'<p>Request body is %(request_body)r</p>' % locals(),
'<p>Actual set of headers received:</p>',
'<ul>',
]
for request_header_name, request_header_value in request_headers.items():
response_body.append('<li><b>%r</b> == %r</li>' % (request_header_name,
request_header_value))
response_body.append('</ul></body></html>')
response_body_raw = ''.join(response_body)
# Clearly state that connection will be closed after this response,
# and specify length of response body
response_headers = {
'Content-Type': 'text/html; encoding=utf8',
'Content-Length': len(response_body_raw),
'Connection': 'close',
}
response_headers_raw = ''.join('%s: %s\n' % (k, v) for k, v in \
response_headers.items())
# Reply as HTTP/1.1 server, saying "HTTP OK" (code 200).
response_proto = 'HTTP/1.1'.encode()
response_status = '200'.encode()
response_status_text = 'OK'.encode() # this can be random
# sending all this stuff
client_sock.send(b'%s %s %s' % (response_proto, response_status,
response_status_text))
client_sock.send(response_headers_raw.encode())
client_sock.send(b'\n') # to separate headers from body
client_sock.send(response_body_raw.encode())
# and closing connection, as we stated before
finally:
client_sock.close()
run()

InformationsquelleAutor Andre Duarte

Vous devez vous connecter pour publier un commentaire.