\documentclass[a4paper,12pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage{geometry}
\geometry{a4paper, margin=2.5cm}
\usepackage{graphicx}
\usepackage[hidelinks]{hyperref}
\usepackage{listings}
\usepackage{xcolor}

\definecolor{codegray}{rgb}{0.5,0.5,0.5}
\definecolor{codepurple}{rgb}{0.58,0,0.82}
\definecolor{backcolour}{rgb}{0.95,0.95,0.92}

\lstdefinestyle{mystyle}{
    backgroundcolor=\color{backcolour},   
    commentstyle=\color{codegray},
    keywordstyle=\color{blue},
    numberstyle=\tiny\color{codegray},
    stringstyle=\color{codepurple},
    basicstyle=\ttfamily\footnotesize,
    breakatwhitespace=false,         
    breaklines=true,                 
    captionpos=b,                    
    keepspaces=true,                 
    numbers=left,                    
    numbersep=5pt,                  
    showspaces=false,                
    showstringspaces=false,
    showtabs=false,                  
    tabsize=2
}
\lstset{style=mystyle}

\title{\textbf{Compte-Rendu TP6} \\ Programmation Répartie - ONC RPC}
\author{Votre Nom et Prénom}
\date{\today}

\begin{document}

\maketitle
\tableofcontents
\newpage

\section{Rappel du sujet}
L'objectif de ce TP est de se familiariser avec la mise en œuvre de systèmes distribués en utilisant le protocole ONC RPC en environnement Java, via la librairie Remote Tea. 

Le TP s'articule autour de deux exercices principaux :
\begin{enumerate}
    \item \textbf{Un serveur de calcul :} Implémentation d'un service RPC capable d'effectuer des opérations arithmétiques basiques (addition, soustraction, multiplication, division, modulo) sur des entiers et des flottants, en gérant plusieurs versions d'un même programme RPC.
    \item \textbf{Un serveur de chat :} Conception et développement d'un système de discussion en temps réel. Le système repose sur une architecture où le serveur central diffuse les messages à l'ensemble des clients connectés. Les clients agissent également comme des serveurs secondaires pour recevoir ces notifications asynchrones.
\end{enumerate}

\section{Analyse du sujet}

\subsection{Exercice 1 : Serveur de Calcul}
Le problème principal réside dans la définition de l'interface en langage RPCL (\texttt{.x}) et la gestion des deux versions (Int et Float) du service. Une fois le squelette généré par \texttt{jrpcgen}, l'enjeu est de surcharger les méthodes distantes côté serveur pour implémenter la logique métier, et d'invoquer ces méthodes côté client de manière transparente.

\subsection{Exercice 2 : Serveur de Chat}
Contrairement à une requête classique client-serveur (synchrone), un chat requiert que le serveur puisse contacter le client de manière asynchrone dès qu'un nouveau message est reçu. L'architecture nécessite donc une communication bidirectionnelle :
\begin{itemize}
    \item Le \textbf{serveur principal} qui écoute sur un port fixe et maintient une liste des clients connectés (adresse IP et port d'écoute).
    \item Le \textbf{client principal} qui initie une connexion, envoie ses messages au serveur central, mais déploie également un \textbf{serveur secondaire} (dans un thread séparé) écoutant sur un port dynamique pour recevoir en continu les messages diffusés.
\end{itemize}

\section{Choix techniques effectués}

Pour répondre aux contraintes du sujet, plusieurs choix techniques ont été réalisés :

\begin{itemize}
    \item \textbf{Framework et librairies :} Utilisation de la librairie Java \texttt{Remote Tea} pour l'implémentation du protocole ONC RPC. La compilation utilise \texttt{jrpcgen.jar} pour générer les stubs et les skeletons, et \texttt{oncrpc.jar} pour gérer l'exécution.
    \item \textbf{Serveur de calcul :} Le fichier \texttt{.x} définit un seul numéro de programme (0x22222220) et deux versions (1 pour entiers, 2 pour flottants). Le serveur hérite du skeleton généré et implémente chaque fonction arithmétique.
    \item \textbf{Architecture du Chat :} 
    \begin{itemize}
        \item Le serveur central stocke les informations de chaque client sous la forme d'une chaîne de caractères \texttt{"AdresseIP:Port"}.
        \item Lors du démarrage d'un client, celui-ci choisit aléatoirement un port d'écoute unique et lance un thread serveur local pour récupérer les messages.
        \item Lors d'un appel à \texttt{ENVOI\_1} par un client, le serveur principal agit en tant que client RPC pour contacter successivement chaque adresse enregistrée et appeler leur méthode \texttt{RECEPTION\_1}.
        \item Utilisation du protocole TCP (\texttt{OncRpcProtocols.ONCRPC\_TCP}) pour assurer la fiabilité des échanges et le bon ordre des messages de chat.
    \end{itemize}
\end{itemize}

\section{Résultats et tests}

Des batteries de tests ont été effectuées pour s'assurer du bon fonctionnement des deux programmes :

\subsection{Serveur de calcul}
Le client est capable de se connecter au serveur (préalablement lancé et enregistré auprès de \texttt{jportmap}) et d'invoquer avec succès les calculs sur les deux versions (entiers et flottants). Les résultats retournés par le serveur sont corrects, démontrant ainsi la bonne sérialisation et transfert des données (XDR).

\begin{figure}[h]
    \centering
    % Remplacez 'capture_calcul.png' par le nom de votre capture d'écran
    \includegraphics[width=0.7\textwidth]{capture_calcul.png} 
    \caption{Test du client de calcul avec le menu interactif}
    \label{fig:test_calcul}
\end{figure}

\subsection{Serveur de chat}
Le scénario de test suivant a été validé :
\begin{enumerate}
    \item Lancement de \texttt{jportmap} en tâche de fond.
    \item Lancement du serveur de chat \texttt{ChatServerMain}.
    \item Lancement d'un premier client, saisie de l'IP (\texttt{localhost}), génération d'un port dynamique, et enregistrement au serveur avec le pseudo "Alice".
    \item Lancement d'un deuxième client sur le même principe avec le pseudo "Bob".
    \item L'envoi d'un message par "Alice" est immédiatement reçu et notifié au serveur principal qui le redistribue, via un appel RPC inversé, au client "Bob" et au client "Alice". 
\end{enumerate}

Le système se comporte de manière stable. Plusieurs terminaux locaux ont été utilisés pour simuler un contexte fortement concurrent.

\begin{figure}[h]
    \centering
    % Remplacez 'capture_chat.png' par le nom de votre capture d'écran
    \includegraphics[width=0.9\textwidth]{capture_chat.png} 
    \caption{Test de communication bidirectionnelle entre le serveur et les clients}
    \label{fig:test_chat}
\end{figure}

\section{Conclusion}

Ce TP a permis d'assimiler les principes fondamentaux de la programmation répartie avec ONC RPC en Java, ainsi que l'utilisation indispensable d'outils de sérialisation pour le passage d'arguments et du \textit{portmapper} pour l'allocation dynamique des ports.

\textbf{Difficultés rencontrées :} \\
La mise en place de l'architecture bidirectionnelle pour le serveur de chat a représenté la principale difficulté. En effet, il a fallu concevoir un "serveur dans le client" tournant en arrière-plan pour recevoir les \textit{callbacks} du serveur central, le tout en gérant correctement les \textit{threads} pour ne pas bloquer l'écoute de la saisie utilisateur au clavier. 

\textbf{Limites et perspectives d'évolution :}
\begin{itemize}
    \item \textbf{Déconnexion des clients :} Le système de chat actuel ne prend pas en compte la déconnexion volontaire ou brutale d'un client. Si un client quitte le chat, le serveur essaiera de lui envoyer des messages, ce qui génère une exception et sature le réseau. Une fonction RPC supplémentaire \texttt{DECONNEXION\_1} pourrait régler ce problème.
    \item \textbf{Richness des messages :} Le passage de paramètres complexes (objet message contenant la date, l'auteur, etc., définis via des \texttt{struct} en RPCL) au lieu d'une simple chaîne de caractères concaténée permettrait de structurer et d'enrichir l'application.
    \item \textbf{Interface Graphique :} L'ajout d'une IHM (via Swing ou JavaFX) pour le client de chat rendrait le système beaucoup plus convivial pour les utilisateurs finaux.
\end{itemize}

\end{document}
