Protocole "sparse" de CargoLe protocole de registre "sparse" de Cargo est désormais disponible en version stable pour la lecture de l'index des crates (l'unité de compilation en Rust), ainsi que l'infrastructure sur https://index.crates.io/ pour celles publiées dans le registre primaire crates.io. Le protocole git précédent (qui est toujours la valeur par défaut) clone un référentiel qui indexe tous les crates disponibles dans le registre.
Pour que Cargo puisse déterminer quelles crates existent sur crates.io, il télécharge et lit un "index" qui répertorie toutes les versions de tous les crates. L'index réside dans un référentiel git hébergé sur GitHub. Cargo récupère et stocke l'index dans le répertoire personnel de Cargo. Ce système permet à GitHub de gérer le traitement côté serveur et offre un moyen pratique de récupérer progressivement les nouvelles mises à jour.
Cependant, comme l'index a considérablement augmenté au fil du temps, ce système a commencé à atteindre des limites d'évolutivité, et les récupérations et mises à jour initiales continuent de ralentir. Vous avez peut-être remarqué une pause lorsque Cargo affiche Mise à jour de l'index crates.io ou lors de la phase de « résolution des deltas »*:
Envoyé par affichage à l'écranUpdating crates.io index
Fetch [=================> ] 74.01%, (64415/95919) resolving deltas
Fetch [=================> ] 74.01%, (64415/95919) resolving deltas
C'est dans ce contexte qu'elle a introduit un nouveau service sur https://index.crates.io/ pour héberger l'index crates.io. Si vous êtes derrière un pare-feu ou un proxy restrictif, vous devrez peut-être autoriser explicitement Cargo à accéder à ce site.
Le nouveau protocole devrait fournir une amélioration significative des performances lors de l'accès à crates.io, car il ne téléchargera que des informations sur le sous-ensemble de crates que vous utilisez réellement.
Pour utiliser le protocole sparse avec crates.io, définissez la variable d'environnement CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse ou modifiez votre fichier .cargo/config.toml pour ajouter*:
| Code Rust : | Sélectionner tout |
1 2 | [registries.crates-io] protocol = "sparse" |
En somme
Cargo prend en charge deux protocoles de registre distants*: git et sparse. Le protocole git stocke les fichiers d'index dans un référentiel git et le protocole sparse récupère les fichiers individuels via HTTP :
- Protocole Git : le protocole git n'a pas de préfixe de protocole dans l'URL d'index. Par exemple, l'URL de l'index git pour crates.io est https://github.com/rust-lang/crates.io-index. Cargo met en cache le référentiel git sur le disque afin qu'il puisse récupérer efficacement les mises à jour de manière incrémentielle.
- Protocole sparse : le protocole sparse utilise le préfixe de protocole sparse+ dans l'URL du registre. Par exemple, l'URL d'index fragmenté pour crates.io est sparse+https://index.crates.io/. Le protocole fragmenté télécharge chaque fichier d'index à l'aide d'une requête HTTP individuelle. Étant donné que cela entraîne un grand nombre de petites requêtes HTTP, les performances sont considérablement améliorées avec un serveur qui prend en charge le pipelining et HTTP/2.
Il est actuellement prévu que le protocole sparse devienne la valeur par défaut pour crates.io dans la version 1.70.0 dans quelques mois.
Construction locale de PIN
La nouvelle macro pin! construit un Pin<&mut T> à partir d'une expression T, capturée anonymement dans l'état local. Ceci est souvent appelé épinglage de pile, mais cette "pile" peut également être l'état capturé d'une async fn ou d'un bloc. Cette macro est similaire à certains crates, comme tokio::pin!, mais la bibliothèque standard peut tirer parti des éléments internes de Pin et de l'extension de durée de vie temporaire pour une macro plus ressemblant à une expression.
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 | /// Exécute un future jusqu'à son achèvement. fn block_on<F: Future>(future: F) -> F::Output { let waker_that_unparks_thread = todo!(); let mut cx = Context::from_waker(&waker_that_unparks_thread); // Pin the future so it can be polled. let mut pinned_future = pin!(future); loop { match pinned_future.as_mut().poll(&mut cx) { Poll::Pending => thread::park(), Poll::Ready(result) => return result, } } } |
Dans cet exemple, le future d'origine sera déplacé dans un local temporaire, référencé par le nouveau pinned_future avec le type Pin<&mut F>, et ce pin est soumis au vérificateur d'emprunt normal pour s'assurer qu'il ne peut pas survivre à ce local.
Gestionnaire d'erreurs allocpar défaut
Lorsque alloc échoue dans Rust, des API comme Box::new et Vec::push n'ont aucun moyen d'indiquer cet échec, donc un chemin d'exécution divergent doit être pris. Lors...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.