Differences
This shows you the differences between two versions of the page.
|
sde2:laboratoare:10_rust [2023/05/14 01:23] cristiana.andrei [Renvoyer du vrai HTML] |
sde2:laboratoare:10_rust [2023/05/15 23:50] (current) cristiana.andrei [TP 10 - Socket] |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== TP 09 - Socket ====== | + | ====== TP 10 - Socket ====== |
| + | |||
| + | <note warning> | ||
| + | Vous devez **accepter** le assignment d'ici et travailler avec ce repository: [[https://classroom.github.com/a/_yii16eB|Lab10]] | ||
| + | </note> | ||
| ===== Objectifs ===== | ===== Objectifs ===== | ||
| Line 138: | Line 142: | ||
| </code> | </code> | ||
| + | ==== Transformer notre serveur monothread en un serveur multithread ==== | ||
| + | À l'heure actuelle, le serveur traitera chaque demande à tour de rôle, ce qui signifie qu'il ne traitera pas une deuxième connexion tant que la première n'aura pas terminé le traitement. Si le serveur recevait de plus en plus de requêtes, cette exécution en série serait de moins en moins optimale. Si le serveur reçoit une requête dont le traitement est long, les requêtes suivantes devront attendre que la requête longue soit terminée, même si les nouvelles requêtes peuvent être traitées rapidement. | ||
| + | |||
| + | === Thread pool === | ||
| + | Un pool de threads est un groupe de threads générés qui attendent et sont prêts à gérer une tâche. Lorsque le programme reçoit une nouvelle tâche, il affecte l'un des threads du pool à la tâche, et ce thread traitera la tâche. Les threads restants dans le pool sont disponibles pour gérer toutes les autres tâches qui arrivent pendant le traitement du premier thread. Lorsque le premier thread a terminé de traiter sa tâche, il est renvoyé dans le pool de threads inactifs, prêt à gérer une nouvelle tâche. Un pool de threads vous permet de traiter les connexions simultanément, augmentant ainsi le débit de votre serveur. | ||
| + | |||
| + | Nous limiterons le nombre de threads dans le pool à un petit nombre pour nous protéger des attaques par Denial of Service (DoS) ; si notre programme créait un nouveau fil pour chaque requête au fur et à mesure qu'elle arrivait, quelqu'un faisant 10 millions de requêtes à notre serveur pourrait créer des ravages en utilisant toutes les ressources de notre serveur et en interrompant le traitement des requêtes. | ||
| + | |||
| + | Plutôt que de générer des threads illimités, nous aurons alors un nombre fixe de threads en attente dans le pool. Les demandes qui arrivent sont envoyées au pool pour traitement. Le pool maintiendra une file d'attente des demandes entrantes. Chacun des threads du pool supprimera une demande de cette file d'attente, traitera la demande, puis demandera à la file d'attente une autre demande. Avec cette conception, nous pouvons traiter jusqu'à N requêtes simultanément, où N est le nombre de threads. Si chaque thread répond à une requête de longue durée, les requêtes suivantes peuvent toujours être sauvegardées dans la file d'attente, mais nous avons augmenté le nombre de requêtes de longue durée que nous pouvons gérer avant d'atteindre ce point. | ||
| + | |||
| + | === Création d'un nombre fini de threads === | ||
| + | Nous voulons que notre pool de threads fonctionne de manière similaire et familière, de sorte que le passage de threads à un pool de threads ne nécessite pas de modifications importantes du code qui utilise notre API. | ||
| + | |||
| + | <code c> | ||
| + | fn main() { | ||
| + | let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); | ||
| + | let pool = ThreadPool::new(4); | ||
| + | |||
| + | for stream in listener.incoming() { | ||
| + | let stream = stream.unwrap(); | ||
| + | |||
| + | pool.execute(|| { | ||
| + | handle_connection(stream); | ||
| + | }); | ||
| + | } | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | <note important> | ||
| + | Voici à quoi devrait ressembler le main **après** l'implémentation du trait ThreadPool. Pour plus de détails sur cette implémentation, veuillez lire les chapitres restants de la documentation, en continuant à partir [[https://doc.rust-lang.org/book/ch20-02-multithreaded.html#creating-a-finite-number-of-threads|d'ici]]. | ||
| + | </note> | ||
| ===== Bibliographie ===== | ===== Bibliographie ===== | ||
| * Singlethreaded web server [[https://doc.rust-lang.org/book/ch20-01-single-threaded.html|en]], [[https://jimskapt.github.io/rust-book-fr/ch20-01-single-threaded.html|fr]] | * Singlethreaded web server [[https://doc.rust-lang.org/book/ch20-01-single-threaded.html|en]], [[https://jimskapt.github.io/rust-book-fr/ch20-01-single-threaded.html|fr]] | ||
| * A simple TCP server [[https://www.youtube.com/watch?v=RJS6wMMwiA8]] | * A simple TCP server [[https://www.youtube.com/watch?v=RJS6wMMwiA8]] | ||
| + | * Rust TcpListener [[https://doc.rust-lang.org/std/net/struct.TcpListener.html]] | ||
| + | * Rust net::Shutdown [[https://doc.rust-lang.org/std/net/enum.Shutdown.html]] | ||
| - | ===== Sujets ===== | + | |
| - | - Clonez le [[https://github.com/UPB-FILS-SdE2/Solutions]] | + | ===== Exercices ===== |
| - | - Exécutez le programme dans tp9/ex1. Répondez aux questions posées par le programme. | + | <note important> |
| + | Executer la commande ''sudo apt install netcat'' avant de resoudre les exercices. | ||
| + | </note> | ||
| + | |||
| + | - Exécutez le programme dans ex1. | ||
| - Résolvez les lignes TODO (dans l'ordre) à partir de ex1. | - Résolvez les lignes TODO (dans l'ordre) à partir de ex1. | ||
| - Résolvez les lignes TODO (dans l'ordre) de ex2. | - Résolvez les lignes TODO (dans l'ordre) de ex2. | ||
| - Résolvez les lignes TODO (dans l'ordre) de ex3. | - Résolvez les lignes TODO (dans l'ordre) de ex3. | ||
| - Implémentez ex1 et ex2 à l'aide de sockets UDP. | - Implémentez ex1 et ex2 à l'aide de sockets UDP. | ||
| - | |||
| - | ===== Solutions ===== | ||
| - | [[https://github.com/UPB-FILS-SdE2/Solutions/tree/main/tp9|Solutions]] | ||
