Rust : Tokio - Historique des versions

Justine le 22 août 2024 à 14:34

2024-08-22T14:34:58Z

@@ Ligne 198 : / Ligne 198 : @@
          });
+     }
+}
 </nowiki>

Justine le 19 août 2024 à 15:24

2024-08-19T15:24:37Z

@@ Ligne 136 : / Ligne 136 : @@
 On va avoir besoin de sockets TCP entrants sur le port 6379. On le fait avec tokio::net::TcpListener.
 <blockquote>
 Many of Tokio's types are named the same as their synchronous equivalent in the Rust standard library. When it makes sense, Tokio exposes the same APIs as std but using async fn.
 </blockquote>

Justine le 19 août 2024 à 14:35

2024-08-19T14:35:19Z

← Version précédente		Version du 19 août 2024 à 14:35
Ligne 136 :		Ligne 136 :

	On va avoir besoin de sockets TCP entrants sur le port 6379. On le fait avec tokio::net::TcpListener.		On va avoir besoin de sockets TCP entrants sur le port 6379. On le fait avec tokio::net::TcpListener.
	<~~quote~~>Many of Tokio's types are named the same as their synchronous equivalent in the Rust standard library. When it makes sense, Tokio exposes the same APIs as std but using async fn.</~~quote~~>		<blockquote>
			Many of Tokio's types are named the same as their synchronous equivalent in the Rust standard library. When it makes sense, Tokio exposes the same APIs as std but using async fn.
			</blockquote>

Justine le 19 août 2024 à 14:34

2024-08-19T14:34:09Z

← Version précédente		Version du 19 août 2024 à 14:34
Ligne 136 :		Ligne 136 :

	On va avoir besoin de sockets TCP entrants sur le port 6379. On le fait avec tokio::net::TcpListener.		On va avoir besoin de sockets TCP entrants sur le port 6379. On le fait avec tokio::net::TcpListener.
	> Many of Tokio's types are named the same as their synchronous equivalent in the Rust standard library. When it makes sense, Tokio exposes the same APIs as std but using async fn.		<quote>Many of Tokio's types are named the same as their synchronous equivalent in the Rust standard library. When it makes sense, Tokio exposes the same APIs as std but using async fn.</quote>

Justine le 19 août 2024 à 14:33

2024-08-19T14:33:51Z

← Version précédente		Version du 19 août 2024 à 14:33
Ligne 129 :		Ligne 129 :

	= Spawning =		= Spawning =
			On bouge le code précendent en example.
			mkdir -p examples
			mv src/main.rs examples/hello-redis.rs

			== Sockets entrants ==

			On va avoir besoin de sockets TCP entrants sur le port 6379. On le fait avec tokio::net::TcpListener.
			> Many of Tokio's types are named the same as their synchronous equivalent in the Rust standard library. When it makes sense, Tokio exposes the same APIs as std but using async fn.

Justine le 19 août 2024 à 14:24

2024-08-19T14:24:30Z

← Version précédente		Version du 19 août 2024 à 14:24
Ligne 127 :		Ligne 127 :

	Tokio a beaucoup de fonctionnalités : TCP, UDP, sockets unix, etc. Nous avons ici utilisé la feature "full" pour l'exemple mais on peut en enlever pour alléger la compilation.		Tokio a beaucoup de fonctionnalités : TCP, UDP, sockets unix, etc. Nous avons ici utilisé la feature "full" pour l'exemple mais on peut en enlever pour alléger la compilation.

			= Spawning =

Justine le 19 août 2024 à 14:24

2024-08-19T14:24:13Z

← Version précédente		Version du 19 août 2024 à 14:24
Ligne 97 :		Ligne 97 :
	hello		hello
	world		world

			La valeur de retour d'une "async fn" est un type anonyme qui implément le trait "Future".

			== Fonction main asynchrone ==
			La fonction main utilisée ici est différente de ce qu'on trouve habituellement : elle est asynchrone et annotée avec "#[tokio::main]". Une fonction async est nécessaire car on veut entrer dans un environnement asynchrone. Cependant, elle doit être exécutée par un runtime, qui contient le task scheduler, les I/O, les timers, etc. C'est le rôle de la macro #[tokio::main].

			Cette macro sert à transformer notre 'async fn main' en une 'fn main()' synchrone qui initialize une instance du runtime et lance la fonction main asynchrone.

			Avec ça:
			<nowiki>
			#[tokio::main]
			async fn main() {
			println!("hello");
			}
			</nowiki>

			On a en réalité

			<nowiki>
			fn main() {
			let mut rt = tokio::runtime::Runtime::new().unwrap();
			rt.block_on(async {
			println!("hello");
			})
			}
			</nowiki>

			== Features de Tokio ==

			Tokio a beaucoup de fonctionnalités : TCP, UDP, sockets unix, etc. Nous avons ici utilisé la feature "full" pour l'exemple mais on peut en enlever pour alléger la compilation.

Justine le 19 août 2024 à 14:17

2024-08-19T14:17:17Z

@@ Ligne 33 : / Ligne 33 : @@
   //Cargo.toml
   tokio = { version = "1", features = ["full"] }
-  mini-redis = "0.4
+  mini-redis = "0.4"

Justine : Page créée avec « = A propos de cette page = Il s'agit de mes notes issues du tuto d'utilisation de l'environnement Tokio : [https://tokio.rs/tokio/tutorial ici] = Présentation = Tokio est un runtime asynchrone pour Rust, et fournit les outils pour créer des applications asynchrone utilisant le réseau. Les composants principaux sont: * Un runtime multi-process pour l'exécution de code asynchrone * Une version asynchrone de la librairie standard * Un grand ecosystème de li... »

2024-08-19T13:59:30Z

Page créée avec « = A propos de cette page = Il s'agit de mes notes issues du tuto d'utilisation de l'environnement Tokio : [https://tokio.rs/tokio/tutorial ici] = Présentation = Tokio est un runtime asynchrone pour Rust, et fournit les outils pour créer des applications asynchrone utilisant le réseau. Les composants principaux sont: * Un runtime multi-process pour l'exécution de code asynchrone * Une version asynchrone de la librairie standard * Un grand ecosystème de li... »

Nouvelle page

= A propos de cette page =

Il s'agit de mes notes issues du tuto d'utilisation de l'environnement Tokio : [https://tokio.rs/tokio/tutorial ici]

= Présentation =

Tokio est un runtime asynchrone pour Rust, et fournit les outils pour créer des applications asynchrone utilisant le réseau. Les composants principaux sont:

* Un runtime multi-process pour l'exécution de code asynchrone
* Une version asynchrone de la librairie standard
* Un grand ecosystème de librairies associées.

Son rôle est avant tout d'accélerer les applications dans le cas où elles sont dépendante d'IO réseau en grande quantité, et pas dépendantes du CPU. Il n'est pas non plus intéressant pour accéder à un grand nombre de fichiers simultanément car les OS n'ont généralement pas d'API asynchrone pour les filesystems.

= Setup =

Le but du tutoriel est de montrer comment implémenter un client et un serveur Redis, avec un petit ensemble de commandes Redis. Ce projet s'appelle Mini-Redis et est [https://github.com/tokio-rs/mini-redis sur Github].

Avec une version récente de Rust, on commence par le serveur mini-redis, qui nous permettra de tester notre client.
cargo install mini-redis
//Lancer le serveur
mini-redis-server
//Depuis un autre terminal
mini-redis-cli get foo
//Doit renvoyer (nil)

= Hello Tokio =

On commence par créer une application très simple, qui va se connecter au serveur mini-redis et passer la clef "hello" à "world".

cargo new my-redis
cd my-redis
//Cargo.toml
tokio = { version = "1", features = ["full"] }
mini-redis = "0.4