lightbug_http
v0.1.5
? Uma estrutura HTTP mojo com asas
O LightBug é uma estrutura HTTP simples e doce para o Mojo que se baseia nas melhores práticas da programação de sistemas, como o Golang Fasthttp e o Rust May_miniHttp.
Isso ainda não está pronto para a produção. Nosso objetivo é acompanhar novos desenvolvimentos no Mojo, mas pode levar algum tempo para chegar a um ponto em que isso é seguro para usar em aplicativos do mundo real.
Atualmente, o LightBug possui os seguintes recursos:
def usadas(de volta ao topo)
A única dependência dura para lightbug_http é o mojo. Aprenda a subir e correr com Mojo no site modular. Depois de ter um projeto mojo configurado localmente,
Adicione o canal mojo-community ao seu mojoproject.toml , por exemplo:
[ project ]
channels = [ " conda-forge " , " https://conda.modular.com/max " , " https://repo.prefix.dev/mojo-community " ] Adicione lightbug_http como uma dependência:
[ dependencies ]
lightbug_http = " >=0.1.5 " Execute magic install na raiz do seu projeto, onde mojoproject.toml está localizado
O Lightbug agora deve ser instalado como uma dependência. Você pode importar todas as importações padrão de uma só vez, por exemplo::
from lightbug_http import *ou importar estruturas e funções individuais, por exemplo
from lightbug_http.service import HTTPService
from lightbug_http.http import HTTPRequest, HTTPResponse, OK , NotFoundExistem alguns manipuladores padrão com os quais você pode brincar:
from lightbug_http.service import Printer # prints request details to console
from lightbug_http.service import Welcome # serves an HTML file with an image (currently requires manually adding files to static folder, details below)
from lightbug_http.service import ExampleRouter # serves /, /first, /second, and /echo routes Adicione seu manipulador no lightbug. Passando uma estrutura que satisfaz a seguinte característica:
trait HTTPService :
fn func ( inout self , req : HTTPRequest) raises -> HTTPResponse:
... Por exemplo, para fazer um serviço Printer que imprime alguns detalhes sobre a solicitação de console:
from lightbug_http import *
@value
struct Printer ( HTTPService ):
fn func ( inout self , req : HTTPRequest) raises -> HTTPResponse:
var uri = req.uri
print ( " Request URI: " , to_string(uri.request_uri))
var header = req.headers
print ( " Request protocol: " , req.protocol)
print ( " Request method: " , req.method)
print (
" Request Content-Type: " , to_string(header[HeaderKey. CONTENT_TYPE ])
)
var body = req.body_raw
print ( " Request Body: " , to_string(body))
return OK(body)Inicie um servidor ouvindo em uma porta com seu serviço assim.
from lightbug_http import Welcome, Server
fn main () raises :
var server = Server()
var handler = Welcome()
server.listen_and_serve( " 0.0.0.0:8080 " , handler) Sinta -se à vontade para alterar as configurações em listen_and_serve() para servir em um host e porta específicos.
Agora envie uma solicitação 0.0.0.0:8080 . Você deve ver alguns detalhes sobre a solicitação impressa no console.
Parabéns ? Você está usando o LightBug!
O roteamento não está em escopo para esta biblioteca, mas você pode facilmente configurar rotas:
from lightbug_http import *
@value
struct ExampleRouter ( HTTPService ):
fn func ( inout self , req : HTTPRequest) raises -> HTTPResponse:
var body = req.body_raw
var uri = req.uri
if uri.path == " / " :
print ( " I'm on the index path! " )
if uri.path == " /first " :
print ( " I'm on /first! " )
elif uri.path == " /second " :
print ( " I'm on /second! " )
elif uri.path == " /echo " :
print (to_string(body))
return OK(body) Planejamos adicionar uma funcionalidade de roteamento mais avançada em uma futura biblioteca chamada lightbug_api , consulte o roteiro para obter mais detalhes.
(de volta ao topo)
A tela de boas -vindas padrão mostra um exemplo de como servir arquivos como imagens ou HTML usando o LightBug. O Mojo possui métodos open , read e read_bytes que você pode usar para ler arquivos e servi-los em uma rota. Supondo que você copie um arquivo HTML e uma imagem do repositório do Lightbug em um diretório static na raiz do seu repositório:
from lightbug_http import *
@value
struct Welcome ( HTTPService ):
fn func ( inout self , req : HTTPRequest) raises -> HTTPResponse:
var uri = req.uri
if uri.path == " / " :
var html : Bytes
with open ( " static/lightbug_welcome.html " , " r " ) as f:
html = f.read_bytes()
return OK(html, " text/html; charset=utf-8 " )
if uri.path == " /logo.png " :
var image : Bytes
with open ( " static/logo.png " , " r " ) as f:
image = f.read_bytes()
return OK(image, " image/png " )
return NotFound(uri.path) Crie um arquivo, por exemplo, client.mojo com o código a seguir. Run magic run mojo client.mojo para executar a solicitação a um determinado URL.
from lightbug_http import *
from lightbug_http.client import Client
fn test_request ( inout client : Client) raises -> None :
var uri = URI .parse_raises( " http://httpbin.org/status/404 " )
var headers = Header( " Host " , " httpbin.org " )
var request = HTTPRequest(uri, headers)
var response = client.do(request ^ )
# print status code
print ( " Response: " , response.status_code)
# print parsed headers (only some are parsed for now)
print ( " Content-Type: " , response.headers[ " Content-Type " ])
print ( " Content-Length " , response.headers[ " Content-Length " ])
print ( " Server: " , to_string(response.headers[ " Server " ]))
print (
" Is connection set to connection-close? " , response.connection_close()
)
# print body
print (to_string(response.body_raw))
fn main () -> None :
try :
var client = Client()
test_request(client)
except e:
print (e)O cliente baseado em mojo puro está disponível por padrão. Este cliente também é usado internamente para testar o servidor.
Por padrão, o LightBug usa a implementação de mojo puro para redes. Para usar a biblioteca socket do Python, basta importar o PythonServer em vez do Server com a seguinte linha:
from lightbug_http.python.server import PythonServer Você pode usar todos os comandos de servidor regular da mesma maneira que no servidor padrão. NOTA: Em setembro de 2024, PythonServer e PythonClient lançam um erro de compilação ao iniciar. Há uma questão em aberto para corrigir isso - as contribuições são bem -vindas!
Estamos trabalhando no suporte para o seguinte (os contribuidores são bem -vindos!):
O plano é chegar a um conjunto de recursos semelhantes às estruturas do Python como Starlette, mas com melhor desempenho.
Nossa visão é desenvolver três bibliotecas, com lightbug_http (este repo) como ponto de partida:
lightbug_http - Infraestrutura HTTP e Desenvolvimento Básico de APIlightbug_api - (chegando mais tarde em 2024!)lightbug_web - (Data de lançamento TBD) Framework Web Stack Full para Mojo, semelhante ao NextJs ou SveltekitA idéia é chegar a um ponto em que toda a base de código de um aplicativo Web moderno simples pode ser escrito no MOJO.
No entanto, não fazemos nenhuma promessa - isso é apenas uma visão, e se chegamos lá ou não, depende de muitos fatores, incluindo o apoio da comunidade.
Veja os problemas abertos e envie o seu próprio para ajudar a impulsionar o desenvolvimento do Lightbug.
(de volta ao topo)
As contribuições são o que tornam a comunidade de código aberto um lugar tão incrível para aprender, inspirar e criar. Quaisquer contribuições que você faz são muito apreciadas . Consulte Contribuindo.md para obter mais detalhes sobre como contribuir.
Se você tiver uma sugestão que melhoraria isso, bifór -l e crie uma solicitação de tração. Você também pode simplesmente abrir um problema com a tag "aprimoramento". Não se esqueça de dar uma estrela ao projeto!
git checkout -b feature/AmazingFeature )git commit -m 'Add some AmazingFeature' )git push origin feature/AmazingFeature )(de volta ao topo)
Distribuído sob a licença do MIT. Consulte LICENSE.txt para obter mais informações.
(de volta ao topo)
Valentin Erokhin
Link do projeto: https://github.com/saviorand/mojo-web
(de volta ao topo)
Estávamos desenhando muito nos seguintes projetos:
(de volta ao topo)
Quer que seu nome apareça aqui? Veja contribuindo.md!
Feito com contrib.rocks.
