CS Fundamentals Trainer · Guias
Identificadores persistentes e link rot
Por que uma URL falha como nome, como um DOI é construído e resolvido, como normalizar e verificar identificadores (medido: ISBN-13 e ORCID detectam erros de digitação, DOIs não), por que um 301 quebra atualizações em um navegador real, negociação de conteúdo e regras para projetar seus próprios identificadores.
20 min de leitura
Um endereço web faz dois trabalhos ao mesmo tempo: nomeia uma coisa ("este artigo") e diz onde essa coisa está hoje ("este servidor, este caminho"). Isso funciona até o local mudar. Uma universidade muda o seu site, uma editora troca de plataforma, uma empresa é adquirida, e todo link que usava o local antigo passa a levar a uma página de erro. Os identificadores persistentes são a solução: um nome que permanece o mesmo enquanto o local por trás dele pode mudar. O DOI (Digital Object Identifier) de um artigo científico é o exemplo mais conhecido, e as ideias valem para qualquer sistema que distribui nomes que as pessoas vão guardar por anos. Este guia explica o problema, como um DOI é construído e resolvido, por que os dígitos verificadores importam (e por que os DOIs não têm um) e o que copiar ao projetar identificadores próprios. O guia complementar, Projetando um resolvedor de DOI, constrói o serviço que responde às consultas.
1. O problema: um nome que também é um endereço
Três palavras descrevem como os links falham:
- Link rot: o endereço não responde mais (404, domínio desaparecido, servidor desligado).
- Content drift: o endereço ainda responde, mas a página agora diz algo diferente do que foi citado.
- Reference rot: qualquer um dos dois, visto do lado do leitor: você não consegue voltar ao que o autor quis dizer.
Quão comum é isso? Um grande estudo de artigos acadêmicos (Klein e colegas, 2014, com mais de 1 milhão de referências a recursos web extraídas de mais de 3,5 milhões de artigos) encontrou que um em cada cinco artigos de ciência, tecnologia e medicina sofria de reference rot, e cerca de sete em cada dez entre os artigos que citam recursos web [1]. Esses números são para referências web, não para DOIs, e descrevem 2014; trate-os como a ordem de grandeza do problema, não como uma taxa atual.
O conselho de Tim Berners-Lee, "Cool URIs don't change" [2], está certo, e também é o que falha na prática: as organizações se reorganizam, e um caminho que era um bom nome no ano passado vira um link quebrado. A resposta robusta não é prometer que os endereços nunca mudarão, mas parar de usar o endereço como nome.
2. A ideia: separar o nome do local
Acrescente um nível de indireção. Publique e cite um nome estável; mantenha uma tabela que mapeia o nome para o local atual; quando o local muda, atualize uma linha da tabela, e todas as citações continuam funcionando.
Diagram: A stable name, resolved to a location that can move
A indireção move o problema; não o elimina. Alguém precisa manter a tabela atualizada. Um DOI que aponta para uma página morta ainda é um link quebrado, e só a organização que o registrou pode consertá-lo, então a persistência é um compromisso social e contratual apoiado por software, não uma propriedade da string. O que o software lhe dá é que a correção é uma atualização em um só lugar, em vez de pedir a cada autor que cita que edite cada documento.
3. Como um DOI é construído
Um DOI tem duas partes separadas pela primeira barra:
10.1145 / 362686.362692
└──┬──┘ └─────┬──────┘
prefix suffix
- O prefixo começa com
10.e é seguido por um número que identifica o registrante, a organização que registrou o nome (aqui 1145 é a Association for Computing Machinery). Ele é atribuído por uma agência de registro. - O sufixo é escolhido pelo registrante. Pode ser um contador, uma string opaca ou um estilo mais antigo que embute outros identificadores. Pode conter caracteres como parênteses, colchetes angulares e ponto e vírgula.
- Os DOIs são insensíveis a maiúsculas e minúsculas:
10.1145/ABCe10.1145/abcsão o mesmo nome.
| DOI | O que nomeia |
|---|---|
10.1145/362686.362692 | O artigo de Bloom de 1970 sobre hash coding (citado no guia do crawler) |
10.1145/509907.509965 | O artigo de Charikar por trás do simhash |
10.1371/journal.pone.0115253 | O estudo de reference rot acima |
10.1016/S0169-7552(98)00110-X | Um sufixo "estruturado" mais antigo: carrega o ISSN de uma revista, um ano de dois dígitos, um número de item e um caractere verificador final, e usa parênteses |
Por baixo, o sistema DOI usa o Handle System (as RFCs 3650 a 3652 descrevem sua arquitetura, espaço de nomes e protocolo [3]): um serviço global que resolve um handle encaminhando seu prefixo ao serviço que guarda os registros desse prefixo. O DOI é um padrão por si só (ISO 26324). Diferentes agências de registro cuidam dos registros de diferentes tipos de conteúdo; a Crossref registra a maioria dos artigos e livros acadêmicos, e a DataCite é a agência comumente usada para conjuntos de dados e software. A agência também guarda os metadados (título, autores, data, licença) ao lado do local.
Para exibição, a convenção é mostrar um DOI como um link completo, https://doi.org/10.1145/362686.362692, para que seja clicável e inequívoco. A forma 10.… pura é para bancos de dados.
4. Normalizando: uma chave para cada DOI
Tudo que armazena ou compara DOIs (uma ferramenta de bibliografia, uma verificação de duplicatas, um resolvedor) precisa de uma chave canônica. As pessoas digitam e colam DOIs de muitas formas: com https://doi.org/, com o antigo host dx.doi.org, com doi:, em maiúsculas, com percent-encoding, com um ponto do fim de uma frase grudado. A regra é remover o invólucro, decodificar, converter para minúsculas e verificar o formato:
import re
from urllib.parse import unquote
DOI = re.compile(r"^10\.\d{4,9}/\S+$") # a loose shape check, not a validity check
def normalise_doi(s):
s = s.strip()
s = re.sub(r"^(?:https?://(?:dx\.)?doi\.org/|doi:\s*)", "", s, flags=re.I)
s = unquote(s)
return s.lower() if DOI.match(s) else None
Executei isso nestas entradas:
| Entrada | Normalizada |
|---|---|
https://doi.org/10.1145/362686.362692 | 10.1145/362686.362692 |
HTTP://DX.DOI.ORG/10.1145/362686.362692 | 10.1145/362686.362692 |
doi: 10.1145/362686.362692 | 10.1145/362686.362692 |
10.1016/S0169-7552(98)00110-X | 10.1016/s0169-7552(98)00110-x |
https://doi.org/10.1016/s0169-7552%2898%2900110-x | 10.1016/s0169-7552(98)00110-x (as duas grafias se encontram em uma chave) |
not a doi, 10.12/short | None (rejeitadas) |
Duas ressalvas. Primeiro, o problema da pontuação final é real: ao extrair DOIs de texto corrido, um . ou ) final pode ou não fazer parte do sufixo, porque os sufixos podem legitimamente terminar em ambos. Remova um ., , ou ; final quando o texto for prosa e, na dúvida, consulte o candidato em vez de adivinhar. Segundo, converter para minúsculas é certo para comparação; para exibição, mantenha o que o registrante publicou.
5. Verificando identificadores: dígitos verificadores, e por que os DOIs não têm
Um dígito verificador é um caractere calculado a partir dos outros, de modo que um erro de digitação faça a verificação falhar. O ISBN-13 usa uma soma ponderada módulo 10; o ORCID iD (o identificador usado por pesquisadores) termina com um caractere calculado com ISO 7064 MOD 11-2, em que o valor 10 é escrito X [4]. O algoritmo do ORCID em código:
def orcid_check_digit(first15):
total = 0
for ch in first15:
total = (total + int(ch)) * 2
r = (12 - total % 11) % 11
return "X" if r == 10 else str(r)
def orcid_ok(s):
s = s.replace("-", "")
return len(s) == 16 and s[:15].isdigit() and orcid_check_digit(s[:15]) == s[15]
def isbn13_ok(s):
d = [int(c) for c in s if c.isdigit()]
return len(d) == 13 and sum(x * (1 if i % 2 == 0 else 3) for i, x in enumerate(d)) % 10 == 0
Os exemplos conhecidos passam (978-0-306-40615-7 e a identidade de teste documentada do ORCID, 0000-0002-1825-0097), e as mesmas strings com o último dígito alterado falham. Depois perguntei quão bem cada esquema percebe erros, com 100 000 identificadores aleatórios cada:
| Esquema | Um dígito errado detectado | Dois dígitos adjacentes trocados, detectado |
|---|---|---|
| ISBN-13 | 100,00% | 90,97% |
| ORCID iD | 100,00% | 100,00% |
Ambos pegam todo erro de um único dígito. A troca de vizinhos é onde diferem: no ISBN-13, a troca de dois dígitos que diferem por 5 deixa a soma inalterada (os pesos são 1 e 3, então a mudança é um múltiplo de 10), de modo que cerca de uma troca em dez passa (9% na minha execução); o MOD 11-2 pega toda troca.
Um DOI não tem dígito verificador. Seu sufixo é o que o registrante escolheu, então não há nada a calcular. A verificação de formato acima aceitou 20 000 de 20 000 mudanças de um único dígito em um DOI real: um erro de digitação produz outro nome sintaticamente válido, e a sintaxe não consegue distingui-lo de um artigo diferente. A única verificação confiável é resolvê-lo (perguntar ao resolvedor se o nome existe) ou consultar seus metadados e comparar o título. É também por isso que copiar e colar um DOI em um manuscrito é mais seguro que redigitá-lo.
Lição de projeto para seus próprios identificadores: se as pessoas vão digitá-los ou lê-los em voz alta (um número de pedido, um código de rastreamento, um id de associado), acrescente um caractere verificador; o custo é um caractere e ele elimina a maioria dos erros de digitação. Se são máquinas que os movem (links, ids de API), um dígito verificador acrescenta pouco e uma consulta é a validação real. Um dígito verificador não é um recurso de segurança: qualquer um pode calculá-lo.
6. O resolvedor não deve ser cacheado para sempre
Um resolvedor responde com um redirecionamento. Qual redirecionamento importa, porque navegadores e intermediários fazem cache de alguns deles. Iniciei um pequeno servidor que redirecionava /r/x para /a, visitei-o em um Chromium real, movi o destino para /b e visitei o mesmo endereço de novo no mesmo navegador:
| Redirecionamento | Cache-Control | Depois que o destino mudou, a segunda visita foi para | O resolvedor viu a segunda visita? |
|---|---|---|---|
| 301 | nenhum | /a (errado) | não, respondido pelo cache do navegador |
| 308 | nenhum | /a (errado) | não |
| 302 | nenhum | /b | sim |
| 307 | nenhum | /b | sim |
| 301 | no-store | /b | sim |
| 301 | max-age=60 | /a (errado por até um minuto) | não |
| 302 | max-age=60 | /a (errado por até um minuto) | não |
Um redirecionamento permanente (301, 308) é cacheável por padrão e, sem informação de frescor, os navegadores o mantêm pelo tempo que quiserem [5]. Para um mapeamento que deve mudar (esse é todo o objetivo de um identificador persistente), um redirecionamento permanente em cache vira a promessa do resolvedor de cabeça para baixo: leitores que visitaram uma vez continuam indo ao local antigo depois que o publicador se mudou. Então um resolvedor responde com um redirecionamento temporário (302 ou 307) e escolhe seu cache de propósito com Cache-Control: uma vida curta troca um pouco de obsolescência por muito menos requisições.
7. Um nome, várias representações: negociação de conteúdo
O mesmo DOI pode ser pedido em formatos diferentes. Um navegador envia Accept: text/html e é redirecionado para a página da editora; um gerenciador de referências envia outro valor de Accept e recebe metadados. A documentação da Crossref lista estes valores para requisições enviadas ao resolvedor de DOI [6]:
Cabeçalho Accept | Você recebe |
|---|---|
application/vnd.citationstyles.csl+json | CSL JSON (o que a maioria das ferramentas de citação lê) |
application/x-bibtex | BibTeX |
application/x-research-info-systems | RIS |
text/x-bibliography | uma citação formatada |
application/rdf+xml, text/turtle | RDF |
application/vnd.crossref.unixref+xml | O XML da Crossref |
curl -L -H "Accept: application/vnd.citationstyles.csl+json" https://doi.org/10.1145/362686.362692
curl -L -H "Accept: application/x-bibtex" https://doi.org/10.1145/362686.362692
O -L importa: o resolvedor descobre qual agência de registro guarda o registro e redireciona a requisição para lá, então um cliente que não segue redirecionamentos vê apenas o redirecionamento.
Um detalhe de HTTP para lembrar: quando a mesma URL dá respostas diferentes dependendo de um cabeçalho da requisição, os caches precisam ser avisados, com Vary: Accept, ou um cache compartilhado servirá BibTeX a um navegador. O guia de estratégias de cache cobre o Vary.
8. Outras formas de nomear coisas
| Identificador | O que é | Caractere verificador | Resolvido por |
|---|---|---|---|
| DOI | nome de um objeto publicado; sufixo escolhido pelo registrante | não | doi.org (Handle System) |
| ORCID iD | nome de uma pessoa (um pesquisador) | sim (MOD 11-2) | orcid.org |
| ISBN-13 | nome de uma edição de um livro | sim (mod 10) | nenhum resolvedor único; catálogos |
| UUID (v4) | nome aleatório de 122 bits, sem significado | não | nada; é apenas único |
| URL simples | nome e endereço em um só | não | DNS e o servidor web |
| Snapshot de arquivo | uma cópia do conteúdo em uma data | n/a | um arquivo (por exemplo o Internet Archive) |
Duas estratégias diferentes se escondem nessa tabela. A indireção (DOI, ORCID) mantém o nome estável e atualiza para onde ele aponta. A preservação (um snapshot de arquivo) guarda uma cópia do próprio conteúdo, de modo que a citação sobrevive mesmo que a fonte desapareça. Elas resolvem falhas diferentes: a indireção não ajuda se a editora fecha e ninguém atualiza o registro; um snapshot não ajuda se você quer a versão viva e atual. A escrita acadêmica cuidadosa usa as duas.
9. Projetando identificadores para o seu próprio sistema
Se você vai distribuir nomes que as pessoas guardam (em documentos, favoritos, planilhas, outros sistemas), estas regras evitam arrependimentos:
- Faça o nome opaco. Não ponha nele o título, o dono, a pasta, a data ou o status. Tudo que for significativo um dia estará errado (o título muda, o dono sai), e o identificador não pode mudar.
- Nunca reutilize um identificador, mesmo depois de apagar o que ele nomeava. O link antigo de alguém não pode abrir o documento de um estranho.
- Separe o nome do local com um mapeamento que você controla, e faça o mapeamento atualizável pelo dono, com uma trilha de auditoria.
- Decida as regras de maiúsculas e de caracteres desde o início (insensível a maiúsculas, um alfabeto sem caracteres parecidos como
0eO) e normalize na borda. - Acrescente um caractere verificador se humanos vão digitá-lo.
- Mantenha "removido" como uma resposta real. Quando a coisa é apagada, guarde o nome e responda com uma página tombstone ("isto foi removido em …, aqui está o motivo") e um 410, não um 404. Sistemas no estilo DOI normalmente mantêm o registro e os metadados mesmo quando o conteúdo se foi.
- Decida o que significa uma nova versão. Ou o nome sempre aponta para a versão mais recente, ou cada versão ganha seu próprio nome mais um nome que acompanha a mais recente. Alguns repositórios, como o Zenodo, dão a cada versão o seu próprio DOI e mais um DOI que sempre aponta para a mais nova, de modo que tanto citar uma versão precisa quanto citar "o software" funcionam.
- Escreva a política: quem pode mudar um mapeamento, com que rapidez e o que acontece com os identificadores se a sua organização deixar de existir.
O encurtador em Projetando um encurtador de URL é o primo leve disto: um código curto mapeado para uma URL longa. A diferença é a promessa: um encurtador tem permissão para apodrecer; um serviço de identificadores persistentes existe para cumprir essa promessa.
10. Erros comuns
- Usar o endereço da página como identificador e prometer que não vai mudar.
- Pôr significado no nome (
/2024/physics/smith-thesis) e depois reorganizar. - Responder a um mapeamento mutável com um 301 ou 308. Os clientes fazem cache e nunca veem a atualização (seção 6).
- Tratar um DOI sintaticamente válido como se fosse real. Resolva-o ou consulte seus metadados.
- Comparar DOIs como strings puras. Maiúsculas, invólucros e percent-encoding produzem falsos "diferentes".
- Reutilizar identificadores depois de apagar.
- Apagar o registro quando o conteúdo desaparece, de modo que o nome passa a não significar nada em vez de "removido".
- Supor que o registrante manterá o mapeamento atualizado. Monitore os destinos e persiga os mortos.
11. Perguntas que os entrevistadores gostam de acrescentar
"Por que não usar simplesmente URLs?"
Uma URL funde nome e local, então qualquer mudança quebra todas as citações. Um identificador persistente põe uma tabela entre eles, de modo que uma mudança é uma atualização. O custo é que alguém precisa manter a tabela atualizada, o que é um compromisso organizacional, não código.
"Por que o resolvedor responde com um 302 e não com um 301?"
Porque o mapeamento foi feito para mudar. Navegadores e proxies podem fazer cache de um 301 indefinidamente (no meu teste, uma visita depois da mudança ainda foi ao local antigo e nunca chegou ao resolvedor), então os leitores ficariam presos no local antigo. Um redirecionamento temporário, com um Cache-Control deliberado, deixa as atualizações chegarem às pessoas.
"Como você detectaria um erro de digitação em um identificador?"
Acrescente um caractere verificador se as pessoas o digitam (ISBN, ORCID). Para um identificador sem um, como um DOI, você só pode verificar o formato e depois resolvê-lo. Medi verificações de formato aceitando toda mudança de um único dígito.
"O que acontece com um DOI quando a editora desaparece?"
Nada acontece sozinho: o nome ainda resolve para o último local conhecido, que pode estar morto. Na prática, as agências exigem que os registrantes mantenham os registros atualizados e podem apontar o nome para uma página tombstone; os metadados podem continuar existindo. É por isso que os arquivos e os arranjos de sucessão das editoras importam.
"Como você armazenaria DOIs em um banco de dados?"
Guarde a chave normalizada, em minúsculas, em uma coluna única (e a grafia original ao lado, para exibição), indexe-a e ponha ao lado dela a agência de registro e o último destino verificado. Compare chaves, nunca strings puras.
"Onde você usaria negociação de conteúdo?"
Sempre que um nome tem várias representações e quem pede é uma máquina, não uma pessoa: exportações de citações, API versus HTML para o mesmo recurso, variantes de idioma. Lembre-se do Vary para os caches.
12. Coisas a mencionar em uma entrevista
- Nome e local são duas coisas; link rot, content drift e reference rot são as falhas.
- A indireção (uma tabela de mapeamento) resolve a metade técnica; a persistência também é um compromisso.
- Estrutura do DOI: prefixo, registrante, sufixo opaco, insensível a maiúsculas, resolvido pelo Handle System por uma agência.
- Normalize antes de comparar ou armazenar.
- Dígitos verificadores (ISBN, ORCID) versus nenhum (DOI); resolva para validar.
- 302/307 para mapeamentos mutáveis; 301/308 são cacheados.
- Negociação de conteúdo e
Vary: Accept. - Opaco, nunca reutilizado, tombstones, política de versionamento.
Resumo rápido
- Uma URL é nome e endereço ao mesmo tempo; movê-la quebra todos os links. Cerca de um em cada cinco artigos acadêmicos tinha reference rot em um grande estudo de 2014.
- Um identificador persistente separa o nome estável do local atual; uma atualização da tabela corrige todas as citações, desde que alguém a mantenha.
- Um DOI é
10.<registrante>/<sufixo>, insensível a maiúsculas, sem dígito verificador: valide resolvendo-o. - Normalize (remova invólucros, decodifique, converta para minúsculas) antes de armazenar ou comparar.
- ISBN-13 e ORCID têm caracteres verificadores: ambos pegaram 100% dos erros de um dígito, e o ORCID pegou 100% das trocas adjacentes contra 91% do ISBN-13 no meu teste.
- Os resolvedores redirecionam com 302 ou 307: os navegadores fizeram cache de um 301 e de um 308 e continuaram enviando os leitores ao destino antigo.
- Um DOI pode devolver uma página web ou metadados legíveis por máquina, escolhidos pelo cabeçalho
Accept.
Apêndice: o código dos experimentos
Biblioteca padrão do Python 3 mais o Playwright para o teste de redirecionamento (pip install playwright, playwright install chromium). Tempos e contagens vêm da minha execução; os testes aleatórios usam sementes fixas.
ids.py: dígitos verificadores, detecção de erros e normalização de DOI:
import random, re
from urllib.parse import unquote
# --- check digits ---
def isbn13_ok(s):
d=[int(c) for c in s if c.isdigit()]
return len(d)==13 and sum(x*(1 if i%2==0 else 3) for i,x in enumerate(d))%10==0
def isbn10_ok(s):
ch=[c for c in s.upper() if c.isdigit() or c=="X"]
if len(ch)!=10: return False
v=[10 if c=="X" else int(c) for c in ch]
return sum((10-i)*x for i,x in enumerate(v))%11==0
def orcid_check_digit(first15):
total=0
for ch in first15: total=(total+int(ch))*2
r=(12-total%11)%11
return "X" if r==10 else str(r)
def orcid_ok(s):
s=s.replace("-","")
return len(s)==16 and s[:15].isdigit() and orcid_check_digit(s[:15])==s[15]
print("known good:", isbn13_ok("978-0-306-40615-7"), isbn10_ok("0-306-40615-2"), orcid_ok("0000-0002-1825-0097"), "| known bad:", isbn13_ok("978-0-306-40615-8"), isbn10_ok("0-306-40615-3"), orcid_ok("0000-0002-1825-0098"))
# --- how often does each scheme notice a typo? ---
rnd=random.Random(1)
def rand_isbn13():
d=[9,7,8]+[rnd.randrange(10) for _ in range(9)]
c=(10-sum(x*(1 if i%2==0 else 3) for i,x in enumerate(d))%10)%10
return "".join(map(str,d+[c]))
def rand_orcid():
f="".join(str(rnd.randrange(10)) for _ in range(15)); return f+orcid_check_digit(f)
def mutate_sub(s,digits_only=True):
i=rnd.randrange(len(s)); alt=[c for c in "0123456789" if c!=s[i]]; return s[:i]+rnd.choice(alt)+s[i+1:]
def mutate_swap(s):
while True:
i=rnd.randrange(len(s)-1)
if s[i]!=s[i+1]: return s[:i]+s[i+1]+s[i]+s[i+2:]
N=100_000
for name,gen,ok in (("ISBN-13",rand_isbn13,isbn13_ok),("ORCID iD",rand_orcid,orcid_ok)):
ids=[gen() for _ in range(N)]
sub=sum(not ok(mutate_sub(x)) for x in ids)/N; sw=sum(not ok(mutate_swap(x)) for x in ids)/N
print(f"{name}: one wrong digit noticed {100*sub:.2f}% | two adjacent digits swapped noticed {100*sw:.2f}% ({N} random ids each)")
# --- DOIs have no check digit: only the syntax can be checked ---
DOI=re.compile(r"^10\.\d{4,9}/\S+$")
def normalise_doi(s):
s=s.strip()
s=re.sub(r"^(?:https?://(?:dx\.)?doi\.org/|doi:\s*)","",s,flags=re.I)
s=unquote(s)
return s.lower() if DOI.match(s) else None
dois=["10.1145/362686.362692","10.1145/509907.509965","10.1016/S0169-7552(98)00110-X","10.1371/journal.pone.0115253","10.1002/(SICI)1097-4571(199806)49:8<693::AID-ASI4>3.0.CO;2-O"]
d0="10.1145/362686.362692"
pos=[i for i,c in enumerate(d0) if i>=3 and c.isdigit()] # digits after "10." : registrant and suffix
acc=0
for _ in range(20_000):
i=rnd.choice(pos); alt=rnd.choice([c for c in "0123456789" if c!=d0[i]]); acc+=bool(DOI.match(d0[:i]+alt+d0[i+1:]))
print(f"syntax accepts {acc} of 20000 single-digit changes to {d0} (it cannot tell a typo from another DOI)")
for t in ["https://doi.org/10.1145/362686.362692","HTTP://DX.DOI.ORG/10.1145/362686.362692","doi: 10.1145/362686.362692","10.1016/S0169-7552(98)00110-X","https://doi.org/10.1016/s0169-7552%2898%2900110-x","not a doi","10.12/short"]:
print(f" {t!r:60} -> {normalise_doi(t)!r}")
redir.py: quais redirecionamentos um navegador real guarda em cache depois que o destino muda:
import http.server, socketserver, threading
from playwright.sync_api import sync_playwright
TARGET={"url":"/a"}; HITS=[]; CFG={"code":301,"cc":None}
class H(http.server.BaseHTTPRequestHandler):
def log_message(self,*a): pass
def do_GET(self):
HITS.append(self.path)
if self.path.startswith("/r/"):
self.send_response(CFG["code"]); self.send_header("Location",TARGET["url"])
if CFG["cc"]: self.send_header("Cache-Control",CFG["cc"])
self.send_header("Content-Length","0"); self.end_headers(); return
b=f"landed on {self.path}".encode(); self.send_response(200); self.send_header("Content-Length",str(len(b))); self.end_headers(); self.wfile.write(b)
class S(socketserver.ThreadingMixIn,http.server.HTTPServer): daemon_threads=True
srv=S(("127.0.0.1",8771),H); threading.Thread(target=srv.serve_forever,daemon=True).start()
print("status | Cache-Control | 2nd visit after the target moved | did the resolver see the 2nd visit?")
with sync_playwright() as p:
br=p.chromium.launch()
for code,cc in [(301,None),(308,None),(302,None),(307,None),(301,"no-store"),(301,"max-age=60"),(302,"max-age=60")]:
ctx=br.new_context(); pg=ctx.new_page(); CFG.update(code=code,cc=cc)
key=f"/r/{code}{cc or ''}".replace("=","").replace("-","")
TARGET["url"]="/a"; HITS.clear(); pg.goto("http://127.0.0.1:8771"+key); first=pg.url.rsplit("/",1)[1]
TARGET["url"]="/b"; HITS.clear(); pg.goto("http://127.0.0.1:8771"+key); second=pg.url.rsplit("/",1)[1]; seen=any(h==key for h in HITS)
print(f"{code} | {cc or '(none)':11} | went to /{second} (should be /b) | {'yes' if seen else 'NO, answered from the browser cache'}")
ctx.close()
br.close()
Fontes
- Martin Klein, Herbert Van de Sompel, Robert Sanderson e outros, Scholarly Context Not Found: One in Five Articles Suffers from Reference Rot, PLOS ONE, 2014 (DOI 10.1371/journal.pone.0115253). Os números citados vêm do seu resumo.
- Tim Berners-Lee, Cool URIs don't change, W3C, 1998.
- IETF, RFC 3650: Handle System Overview, com a RFC 3651 (definição de espaço de nomes e serviço) e a RFC 3652 (protocolo). O sistema DOI é construído sobre o Handle System.
- ORCID, Format of the ORCID iD. A estrutura e o caractere verificador ISO 7064 MOD 11-2; o código acima implementa o seu algoritmo.
- IETF, RFC 9110: HTTP Semantics (códigos de status de redirecionamento) e RFC 9111: HTTP Caching.
- Crossref, Content negotiation (valores de
Acceptsuportados) e DOI content negotiation. - Crossref, DOI display guidelines (mostrar DOIs como links completos
https://doi.org/…).
Pratique este tema: Networking & APIs