Durante o processo de desenvolvimento diário, geralmente precisamos modificar alguns arquivos estáticos colocados no CDN (como JavaScript, CSS, arquivos HTML etc.). Nesse processo, esperamos ter uma maneira de mapear o diretório CDN on -line para um diretório no disco rígido local. Dessa forma, quando modificamos um arquivo localmente, não precisamos publicá -lo e podemos ver o efeito imediatamente após a atualização.
Por exemplo, nosso nome de domínio CDN é: http://a.mycdn.com, e o diretório correspondente local é: d:/workassets. Esperamos que todos os acessos a http://a.mycdn.com/* sejam mapeados para o d:/workassets/*. Por exemplo, ao visitar http://a.mycdn.com/s/atp.js, você realmente lê o D: /workassess/atp.js sem baixar arquivos on -line da Internet.
É muito simples implementar essa função, os pontos -chave são os seguintes:
1. Abra um serviço HTTP localmente e ouça a porta 80;
2. Modifique o arquivo hosts do sistema, adicione "127.0.0.1 a.mycdn.com" e vincule o nome de domínio CDN ao endereço do servidor local;
3. Configure o serviço HTTP local. Depois de receber uma solicitação GET, verifique se o arquivo correspondente existe no disco rígido local. Se existir, retorne o conteúdo do arquivo. Se não existir, retorne o conteúdo correspondente na linha.
Como você pode ver, a parte principal é criar um serviço HTTP local. Existem muitos tutoriais nesse sentido, como a instalação de software servidor, como Apache ou NGNIX localmente, e configurando as regras de encaminhamento correspondentes. No entanto, eu pessoalmente acho que esse método ainda é um pouco complicado. O que eu quero introduzir neste artigo é outro método que não requer a instalação do software do servidor.
Como estamos desenvolvendo e depurando localmente, não temos requisitos altos para desempenho e simultaneidade; portanto, não precisamos de um software HTTP profissional como o Apache/NGNIX. Precisamos apenas de um script que possa fornecer serviços HTTP. Por exemplo, use o NodeJS para implementá -lo.
A cópia do código é a seguinte:
/**
* Autor: Oldj
*
**/
var http = requer ("http"),
url = requer ("url"),
caminho = requer ("caminho"),
fs = requer ("fs"),
Local_folders,
base_url;
Local_folders = [// Caminho local, o agente procurará o arquivo no diretório nesta lista, se não for encontrado, vá para o endereço online
"D:/trabalho/ativos"
];
base_url = "http://10.232.133.214"; // Caminho on -line, se o arquivo não puder ser encontrado, depois volte para este endereço
função loadfile (nome do caminho, resposta) {
var i, l = local_folders.length,
fn;
console.log ("Tente carregar" + PathName);
para (i = 0; i <l; i ++) {
fn = local_folders [i] + pathname;
if (path.existsync (fn) && fs.statsync (fn) .isfile ()) {
fs.readfile (fn, function (err, dados) {
Response.writehead (200);
resposta.write (dados);
resposta.END ();
});
retornar;
}
}
Response.Writehead (302, {
"Localização": base_url + nome do caminho
});
resposta.END ();
}
http.createServer (
função (solicitação, resposta) {
var req_url = request.url,
nome do caminho;
// manipula solicitações semelhantes a http://a.tbcdn.cn/?p/global/1.0/global-min.css.tbsp/tbsp.css?t=20110920172000
pathname = req_url.indexof ("??") == -1? url.parse (request.url) .pathname: req_url;
console.log ("Solicitação de '" + Pathname + "' Recebido.");
loadfile (nome do caminho, resposta);
}). Ouça (80);
Observe que você altera os valores das variáveis Local_Folders e BASE_URL acima dos valores necessários. Salve este arquivo, por exemplo, salve-o como local-cdn-proxy.js e, em seguida, execute "Node local-cdn-proxy.js" na linha de comando, e o servidor local será executado. Claro, não se esqueça de vincular hosts.
Ao acessar um caminho através do HTTP, o script acima pesquisará primeiro no diretório local correspondente. Se for encontrado, ele retornará o conteúdo do arquivo correspondente. Se não for encontrado, ele saltará diretamente para o endereço correspondente na linha. Para situações em que não pode ser encontrado, há outra maneira de lidar com isso. O servidor local baixa o conteúdo correspondente do online e o retorna. No entanto, para esse requisito, um salto de 302 é suficiente.
Além da versão NodeJS, também escrevi uma versão Python:
A cópia do código é a seguinte:
#-*-Codificação: UTF-8-*-
#
# Autor: OldJ
#
OS de importação
importar basehttpServer
Local_folders = [
"D:/trabalho/ativos"
]
Base_url = "http://10.232.133.214"
CLASS WebRequestHandler (BASEHTTPSERVER.BASEHTTPREQUESTHAN):
def do_get (self):
Impressão "Solicitação de '%s' recebida". % self.path
Para pasta em local_folders:
fn = os.path.join (pasta, self.path.preplace ("/", os.sep) [1:])
Se os.path.isfile (fn):
self.send_ropnse (200)
self.wfile.write (aberto (fn, "rb"). read ())
quebrar
outro:
self.send_ropSe (302)
self.send_header ("location", "%s%s"%(base_url, self.path))
Server = BASEHTTPSERVER.HTTPSERVER (("0.0.0.0", 80), WebRequestHandler)
Server.serve_forever ()
Como você pode ver, o código na versão Python é muito mais simples do que na versão NodeJS.
As funções dos dois códigos acima são relativamente simples, como o tipo MIME, o comprimento do conteúdo e outras informações do cabeçalho sem conteúdo de saída, e nenhum processamento especial é feito para possíveis operações de bloqueio (como o tempo limite de arquivo, etc.). Para ambientes de desenvolvimento local, eles já estão trabalhando versões e você pode continuar estendendo esses dois scripts para atender a mais necessidades.