quickserv
v0.3.0
SERVIDO QUÁPIDO , NÃO SETUPUP
O QuickServ facilita a criação de aplicativos da Web perigosamente , independentemente da linguagem de programação que você usa.
O QuickServ é um servidor da web sem dependência, ligado a estaticamente, que:
read e write O QuickServ traz a diversão inebriante da Internet dos anos 90 para os anos 2020. É inspirado na Interface Common Gateway (CGI), mas é muito mais fácil de configurar e usar. Ao contrário do CGI, ele funciona fora da caixa, sem procurar arquivos de log obscuros, sem aprender como os cabeçalhos HTTP funcionam, sem brincar com bits de permissão, sem se preocupar com os CORS, não se sabe para onde colocar seus scripts e sem lutar com as configurações Apache mod_cgi .
Ao contrário do CGI, você não precisa saber o que significa qualquer coisa do parágrafo anterior significa usar o QuickServ.
É perfeito para:
O QuickServ não deve ser usado na Internet pública. Ele deve ser usado apenas em redes privadas.
O uso do QuickServ é tão fácil quanto baixar o programa, arrastá -lo para a pasta do projeto e clicar duas vezes para ser executado. Ele detecta automaticamente quais arquivos a serem executados e quais servir diretamente ao usuário.
Baixe para Windows.
Faça uma pasta do projeto e adicione arquivos a ela. Por exemplo, se o Python estiver instalado, crie um arquivo chamado test.py na pasta do projeto que contém:
#!python
# Put your code here. For example:
import random
print ( random . randint ( 0 , 420 ))
Desde que test.py começa com #!something , onde something test.py é o comando para executar o arquivo, o QuickServ saberá executá -lo. Se o QuickServ não estiver executando seu arquivo, adicione -o ao início.
No Windows, o QuickServ também sabe executar automaticamente arquivos que terminam em .exe e .bat . Qualquer outro tipo de arquivo precisa começar com #!something se ele for executado.
Mova o arquivo quickserv_windows_x64.exe baixado para a pasta do projeto.
Clique duas vezes clique em quickserv_windows_x64.exe na pasta do projeto para iniciar o QuickServ. Deixe o acesso através do Windows Defender, se solicitado.
Vá para http://127.0.0.1:42069 (ou o endereço mostrado pelo QuickServ) para se conectar ao seu aplicativo da Web. No exemplo, para executar test.py , acesse http://127.0.0.1:42069/test.py.
Faça o download da versão certa para o seu computador. Se necessário, verifique que tipo de processador seu Mac possui. Você terá que descompactar os arquivos depois de baixá -los.
Faça uma pasta do projeto e adicione arquivos a ela. Por exemplo, se o Python estiver instalado, crie um arquivo chamado test.py na pasta do projeto que contém:
#!python
# Put your code here. For example:
import random
print ( random . randint ( 0 , 420 ))
Se você estiver criando o arquivo com o TextEdit, precisará entrar em Format > Make Plain Text para salvar o arquivo no formato correto.
Desde que test.py começa com #!something , onde something test.py é o comando para executar o arquivo, o QuickServ saberá executá -lo. Se o QuickServ não estiver executando seu arquivo, adicione -o ao início.
No Mac, o QuickServ também sabe executar automaticamente arquivos que foram compilados. Qualquer outro tipo de arquivo precisa começar com #!something se ele for executado.
Mova o arquivo quickserv_macos_x64 ou quickserv_macos_arm64 para a pasta do projeto.
Clique com o botão direito quickserv_macos_x64 ou quickserv_macos_arm64 na pasta do projeto e selecione "Abrir". Em seguida, pressione "Abrir" na caixa de diálogo de confirmação. Depois de executá-lo dessa maneira uma vez, você poderá iniciar o QuickServ simplesmente clicando duas vezes no arquivo.
Vá para http://127.0.0.1:42069 (ou o endereço mostrado pelo QuickServ) para se conectar ao seu aplicativo da Web. No exemplo, para executar test.py , acesse http://127.0.0.1:42069/test.py.
É mais fácil instalar e executar através da linha de comando. Abra o terminal.
Insira os seguintes comandos. Uma senha pode ser necessária para os primeiros comandos.
# Download
sudo curl
--location
--output /usr/local/bin/quickserv
https://github.com/jstrieb/quickserv/releases/latest/download/quickserv_raspi_arm
# Make executable
sudo chmod +x /usr/local/bin/quickserv
# Make a project folder
mkdir -p my/project/folder
# Go to project folder
cd my/project/folder
# Add a test file
cat << EOF > test.py
#!python3
# Put your code here. For example:
import random
print(random.randint(0, 420))
EOF
# Run QuickServ
quickserv Vá para http://127.0.0.1:42069 (ou o endereço mostrado pelo QuickServ) para se conectar ao seu aplicativo da Web. Por exemplo, para executar test.py , acesse http://127.0.0.1:42069/test.py.
Clicar para executar executáveis não possui comportamento consistente nas distritos Linux, por isso é mais fácil instalar e executar através da linha de comando. Dependendo da arquitetura do seu computador, pode ser necessário alterar o nome do arquivo no final do URL de solicitação HTTP curl abaixo.
Veja todas as opções de download na página de lançamentos.
# Download
sudo curl
--location
--output /usr/local/bin/quickserv
https://github.com/jstrieb/quickserv/releases/latest/download/quickserv_linux_x64
# Make executable
sudo chmod +x /usr/local/bin/quickserv
# Make a project folder
mkdir -p /my/project/folder
# Go to project folder
cd /my/project/folder
# Add a test file
cat << EOF > test.py
#!python3
# Put your code here. For example:
import random
print(random.randint(0, 420))
EOF
# Run QuickServ
quickserv Vá para http://127.0.0.1:42069 (ou o endereço mostrado pelo QuickServ) para se conectar ao seu aplicativo da Web. Por exemplo, para executar test.py , acesse http://127.0.0.1:42069/test.py.
Como alternativa, use as instruções abaixo para compilar a partir da fonte.
Compilar e instalar da fonte usando o seguinte comando. É necessária uma versão do GO maior que 1,16 devido à dependência dos sistemas de arquivos incorporados.
go install github.com/jstrieb/quickserv@latestEm seguida, crie a pasta do projeto, preencha -a e execute o QuickServ.
# Make a project folder
mkdir -p /my/project/folder
# Go to project folder
cd /my/project/folder
# Add a test file
cat << EOF > test.py
#!python3
# Put your code here. For example:
import random
print(random.randint(0, 420))
EOF
# Run QuickServ
quickservPara demonstrar os principais recursos do QuickServ, criaremos um aplicativo da Web simples para executar a adição. O código não seguirá as práticas recomendadas, mas mostrará quão pouco é necessário para começar a construir com o QuickServ.
Primeiro, criamos uma pasta de projeto e arrastamos o executável do QuickServ para a pasta, como nas etapas de início.
Em seguida, dentro da pasta, salvamos o seguinte texto como index.html :
< form action =" /calculate " >
< input name =" first " type =" number " > + < input name =" second " type =" number " > = ???
< br >
< button > Calculate </ button >
</ form > Este código envia duas variáveis para a página /calculate . No navegador, parece assim:
Em seguida, criamos uma pasta chamada calculate dentro da pasta do projeto. Dentro da pasta calculate , salvamos o seguinte código como index.py . O nome index.whatever o que diz ao QuickServ para executar esse arquivo quando um usuário visita http://website/calculate em vez de precisar que eles visitem http://website/calculate/index.py .
Preste atenção especial aos comentários do código. Eles destacam vários recursos importantes do QuickServ.
#!python3
# Each QuickServ script must begin with a line like the one above so that
# QuickServ knows how to run the file. This line tells QuickServ that I would
# type `python3 this_file.py` to run this file at the command prompt. For
# example, if you wanted to do `julia this_file.py` instead, then you would
# make the first line of `this_file.py` be `#!julia`.
#
# Since we just want QuickServ to show the HTML code to the user and not run
# it, index.html does not begin with this. The first line is only required when
# QuickServ has to run the code.
import argparse
# All HTML form values get turned into command line arguments. The names are
# formatted like "--name" and the value comes right after the name.
parser = argparse . ArgumentParser ()
parser . add_argument ( "--first" , type = int , required = True )
parser . add_argument ( "--second" , type = int , required = True )
args = parser . parse_args ()
# Print the result -- anything printed out goes right to the user. In this
# case, the output is text. But you can print anything and QuickServ will guess
# the file type. Even printing the contents of image and video files works.
print ( args . first + args . second )Agora, clique duas vezes, o QuickServ na pasta do projeto e experimente -o no seu navegador. É isso!
Veja os exemplos vinculados na próxima seção para obter mais demonstrações do QuickServ. Leia mais detalhes na seção de como funciona e no próprio código. A seção Avançada possui informações adicionais sobre o ambiente do ambiente configurado para executáveis que ele é executado.
Todos os exemplos estão localizados na pasta examples , que é um submódulo Git conectado ao repo JStrieB/QuickServ-Examples. Vá ao repositório para obter mais informações sobre como executar os exemplos.
Alguns destaques:
| Resumo | Linguagem | Windows | Mac | Linux |
|---|---|---|---|---|
| YouTube para GIF | Concha | |||
| Crie filtros de Bloom | C | |||
| Lista de filmes sincronizados | TypeScript | |||
| Intérprete do Brainfuck | Assembléia X86-64 | |||
| Mandelbrot Zoom | Concha | |||
| Painel de criptomoeda | Ir | |||
| Ferramentas em PDF | Python | |||
| Markdown de tiponete como pdf | ML padrão |
Todo o código do QuickServ vive em quickserv.go . Este arquivo bem conceituado tem cerca de 700 linhas de comprimento e deve levar um programador experiente sem familiaridade de Golang no máximo uma hora para ler.
O QuickServ tem duas partes principais. O primeiro é um procedimento de inicialização, execute exatamente uma vez na inicialização. A segunda é uma função de manipulador, chamada sempre que um usuário faz uma solicitação HTTP para o servidor.
Quando o QuickServ é iniciado, ele verifica os sinalizadores de configuração da linha de comando, abre um arquivo de log se for passado com --logfile (caso contrário, ele registra na saída padrão) e altera os diretórios se um diretório de trabalho for passado com --dir . Observe que o caminho do arquivo de log é relativo ao diretório de trabalho atual, não em relação ao passado com --dir .
Em seguida, o QuickServ digitaliza o diretório de trabalho em busca de arquivos. Ele imprime todos os arquivos que serão executados. Esse comportamento é útil para determinar se o QuickServ reconhece um script como executável. Ele também imprime informações úteis para o usuário, como o endereço da Web, a ser visitado para acessar o servidor e em qual pasta o servidor está executando, bem como como detê -lo.
Se alguma parte da inicialização falhar, um erro será relatado. No caso de um erro fatal, o QuickServ aguarda a entrada do usuário antes de desistir. Dessa forma, um usuário que clica duas vezes no executável (em vez de iniciá-lo na linha de comando) não tem uma janela e depois desaparece imediatamente, piscando muito rapidamente para que o erro seja lido.
As mensagens de erro são escritas propositadamente com o mínimo de jargão técnico possível, embora algumas sejam inevitáveis. As causas prováveis para os erros também estão incluídas nas mensagens de erro, para que sejam mais fáceis para os usuários identificar e corrigir.
Como a última etapa do procedimento de inicialização, o QuickServ inicia um servidor da Web com uma única função manipuladora para todas as solicitações. O servidor ouve na porta padrão de 42069 , ou em uma porta aleatória se um usuário especificar o sinalizador --random-port -line. Uma porta aleatória seria desejável se o usuário tivesse que mostrar um projeto construído com o QuickServ para alguém sem humor, por exemplo.
Quando um usuário visita uma página da web, o QuickServ lida com a solicitação chamando a função do manipulador solitário.
Primeiro, esta função tenta abrir o arquivo solicitado pelo usuário. Se não conseguir encontrar ou abrir o arquivo, ele tentará servir uma versão padrão do arquivo. Por exemplo, há um favicon.ico incorporado que é servido. Se não houver arquivo padrão correspondendo ao caminho, ele permite que o servidor de arquivos Go integrado lide o erro e responda com um código de erro 404.
Se o arquivo solicitado pelo usuário estiver presente, ele verifica se é um diretório. Se for um diretório, o QuickServ procura um arquivo chamado index.xxx , onde xxx é qualquer extensão de arquivo. Se um arquivo de índice for encontrado, o índice será servido (e possivelmente executado) como se fosse a página original solicitada. Caso contrário, o usuário deve ter solicitado um diretório sem um índice padrão, portanto, o QuickServ responde com uma listagem dos outros arquivos no diretório.
Se o arquivo solicitado pelo usuário estiver presente e não um diretório ( ou seja , é um arquivo regular), o QuickServ verifica se é executável ou não. Nesse caso, ele executa o arquivo que encontrou. Caso contrário, ele retorna o conteúdo do arquivo bruto ao usuário. Nos dois casos, o QuickServ adivinhará qual tipo de arquivo (e, portanto, qual mimetype ) usará para a resposta.
A técnica para determinar se um arquivo é executável depende do sistema operacional de tempo de execução. No Windows, qualquer arquivo com uma extensão .bat ou .exe é considerado executável. Nos sistemas que não são de janelas, qualquer arquivo com o conjunto de bits de permissão executável é considerado executável. Em todos os sistemas, um arquivo é executável se tiver um pseudo-Shebang válido no início. O Shebang deve estar na primeira linha, deve começar com #! , e deve ser um comando válido. Por exemplo, ambos os seguintes são aceitáveis, assumindo que python3 seja instalado e no PATH :
#!/usr/bin/python3#!python3 Para executar um arquivo, o QuickServ executa o próprio arquivo (se for um .exe ou tem o conjunto de bits executável) ou passa o caminho do arquivo como o primeiro argumento para o executável listado em seu shebang. O corpo da solicitação é transmitido para o programa com entrada padrão, e tudo o que é impresso pelo programa na saída padrão é usado como corpo de resposta. Os programas executados não são responsáveis pela escrita - nem capaz de escrever - cabeçalhos de resposta http.
Todas as variáveis de formulário HTTP analisadas (se o Content-Type for x-www-form-urlencoded ) também for aprovada como argumentos da linha de comando quando o programa for executado. Dessa forma, o usuário não precisa analisar as próprias variáveis.
Quaisquer que sejam as impressões do programa executado em erro padrão, é registrado pelo QuickServ, o que significa que ele é impresso na janela do console por padrão. Isso é útil para depuração. Se o programa terminar com um código de saída diferente de zero, o QuickServ responderá com um erro de 500 servidor interno. Caso contrário, ele retorna com 200.
Se a solicitação for uma solicitação de postagem codificada por URL com dados do formulário, o QuickServ URL-Docodes todos os caracteres, exceto por três símbolos: % , & e = . O usuário é responsável por substituí -los. Observe que é importante sempre o URL-Decode % último no programa que processa os dados do formulário.
Não execute o QuickServ na Internet pública. Apenas execute -o em redes privadas.
O QuickServ não foi projetado para uso da produção. Não foi criado para ser rápido ou seguro. O uso do QuickServ na produção coloca seus usuários e você mesmo em risco, não faça isso.
O QuickServ permite que as pessoas construam coisas perigosamente inseguras. Ele não higieniza nenhuma entrada ou saída. Ele usa um processo por solicitação e é suscetível a um ataque de negação de serviço. Seu modelo de segurança presume que os usuários da Web são confiáveis. Essas características facilitam a prototipagem, mas não são seguras na Internet pública.
Para deter o uso do QuickServ na produção, ele é executado na porta 42069 . Espero que isso faça com que todos pensem duas vezes antes de inseri -lo em uma configuração de proxy ou porta reversa. Para uma demonstração mais profissional, o sinalizador de linha de comando --random-port usará uma porta aleatória, determinada em tempo de execução.
O QuickServ é semelhante ao antigo protocolo CGI. Existem muitas razões bem estabelecidas e bem estabelecidas em que o CGI é ruim na produção e todos se aplicam ao Quickserv na produção.
O QuickServ possui opções avançadas configuradas via sinalizadores de linha de comando. Elas mudam como e onde o QuickServ é, bem como onde salva sua saída.
Usage:
quickserv [options]
Options:
--dir string
Folder to serve files from. (default ".")
--logfile string
Log file path. Stdout if unspecified. (default "-")
--no-pause
Don't pause before exiting after fatal error.
--random-port
Use a random port instead of 42069.
Na imitação do CGI, os cabeçalhos HTTP são passados para o programa executado como variáveis de ambiente. Um cabeçalho chamado Header-Name será definido como a variável de ambiente HTTP_HEADER_NAME .
Há também uma variável REQUEST_TYPE que especifica se a solicitação foi GET , POST , etc.
As solicitações HTTP com um corpo passam no corpo para o programa executado em entrada padrão. Na maioria dos casos, o corpo de solicitação é aprovado literalmente. Este não é o caso dos formulários HTML.
Os dados do formulário HTML podem ser lidos nos argumentos da linha de comando, como no tutorial, ou analisados a partir de entrada padrão. Variáveis assumem o formulário
name=value&othername=othervalue
O exemplo de adição simples do tutorial pode ser reescrito para analisar os valores de formulário HTTP a partir da entrada padrão, em vez dos argumentos da linha de comando.
#!python3
import sys
# In the form input, "=" and "&" determine where variables start and end. So if
# they are literally included in the variable name or value, they must be
# specially decoded. This code replaces every instance of the text on the left
# with the text on the right to do the decoding:
# %3D -> =
# %26 -> &
# %25 -> %
#
# NOTE: Order matters! "%" must be decoded last. If not, it can mess with
# decoding the others, since their encoded version uses "%"
def decode_characters ( text ):
text = text . replace ( "%3D" , "=" )
text = text . replace ( "%26" , "&" )
text = text . replace ( "%25" , "%" )
return text
first = second = 0
# Read all of the input into a variable. We are expecting the raw data to look
# like:
# first=123&second=456
data = sys . stdin . read ()
# The raw data looks like the above, so split it into pairs at each "&"
pairs = data . split ( "&" )
for pair in pairs :
# Each pair looks like the following, so split at each "=":
# name=value
name , value = pair . split ( "=" )
# Decode any special characters (=, &, %) now that we have split the
# variables up. This isn't necessary here since we're expecting numbers and
# not expecting any of those characters. But it matters a lot when a user
# could submit text with those characters
name = decode_characters ( name )
value = decode_characters ( value )
# If the name is what we're looking for, store the value for adding
if name == "first" :
first = int ( value )
elif name == "second" :
second = int ( value )
# Print the result -- anything printed out goes right to the user. In this
# case, the output is text. But you can print anything and QuickServ will try and
# guess the file type.
print ( first + second )Este projeto é desenvolvido e mantido ativamente. Se não houver comprometimentos recentes, isso significa que tudo está funcionando bem!
Abra um problema com bugs, sugestões ou perguntas. Isso inclui especialmente discussões sobre como fazer as mensagens de erro o mais claro possível e como tornar as configurações padrão aplicáveis ao maior número possível de usuários.
Pull solicitações sem discussão prévia serão ignoradas - não perca tempo escrevendo código antes de confirmar que ele será mesclado. Como um desenvolvedor solitário e ocupado, é mais fácil ser responsivo quando todas as contribuições do código tiverem contexto.
Se você fizer uma postagem no blog, vídeo, tutorial, projeto de hackathon ou qualquer outra coisa usando o QuickServ, abra um problema ou envie uma mensagem no meu formulário de contato para que eu possa vincular novamente a ele!
Existem algumas maneiras de apoiar o projeto:
Essas coisas me motivam a continuar compartilhando o que eu construo e fornecem validação de que meu trabalho é apreciado! Eles também me ajudam a melhorar o projeto. Desde já, obrigado!
Se você insistir em gastar dinheiro para mostrar seu apoio, encorajo -o a fazer uma doação generosa a uma das seguintes organizações. Ao defender as liberdades da Internet, organizações como essas me ajudam a me sentir confortável lançando trabalho publicamente na web.
Este projeto não seria possível sem a ajuda de:
