Aide sur un programme Client Serveur

**clubmed01** · 22/01/2006, 10h17

Bonjour,

j'aurais besoin d'un coup de pouce sur un programme client serveur que je dois écrire en pseudo-code pour mes études. C'est un bon exercice de révision ; mes bases sont assez loin, mais c'est un bon moyen de travailler mon point faible qu'est la programmation.
Pour l'instant, j'ai du mal à démarrer. j'ai donc besoin d'un tutorat, mais je ne veux pas une solution toute faite, auquel cas je n'aurais rien appris.

Le sujet : Application Client-serveur de réservation de places cinéma.

- clients émettent requêtes de consultation et de réservation (n places)
- processus serveur prend en compte la réservation, créé autant de fils que de réservations (n) qui envoient au client un acquitement ou un message d'erreur.

Les contraintes :

- les informations liées à la réservation (date, séance, cinéma, salle, nombre de places restantes) sont stockées dans une table en mémoire centrale
- processus client et serveur s'éxécutent sur la même machine Linux
- les processus fils du processus serveur Réservation recouvrent le code hérité du père par une code exécutable contenant les actions de réservation.

Dans un premier temps, j'aimerais faire le point sur les outils de communication entre processus que je dois choisir.
De ce que j'ai compris, il y en a plusieurs :
- les tubes : anonymes et nommés
- les files de message (IPC)
- la mémoire partagée (IPC)
- les sémaphores (IPC)
- les sockets (réseaux)

La communication entre C et S est bi-directionnelle et s'éxécute sur la même machine ; je mets donc de coté les tubes et les sockets et je m'oriente donc vers les 3 outils IPC, même si avec les sockets cela reste possible.

Y a-t-il des volontaires pour me guider sur la suite ?

Merci d'avance, j'ai une semaine pour maîtriser tout ça ...

**hegros** · 22/01/2006, 11h56

As tu fais une schéma de fonctionnement général ?

**clubmed01** · 22/01/2006, 14h11

C'est fait. Voici mon schéma :

**hegros** · 22/01/2006, 15h41

Tu pourrais expliquer on schéma..

**clubmed01** · 22/01/2006, 17h58

Un client émet une requête de consultation des places de spectacle. le serveur reçoit la requête, consulte la mémoire partagée (là, je pige pas comment on fait). il renvoit la réponse au client.
Le serveur peut recevoir plusieurs requêtes simultanées en consultation.
Lorsque le client émet une requête de réservation, il consulte la mémoire partagée et bloque celle-ci pour ne pas qu'un autre processus y accède en même temps (une seule écriture à la fois). il faut donc gérer ici la synvhronisation (sémaphores ?).

je pense qu'il faut utiliser entre client et serveur les sockets en local (je rappelle que tout se passe sur la même machine) et qu'au niveau du serveur, voilà ce que dis le sujet, mais le pige pas comment faire :
- le processus serveur prend en compte la réservation, créé autant de fils que de réservations (n) qui envoient au client un acquitement ou un message d'erreur
- les processus fils du processus serveur Réservation recouvrent le code hérité du père par une code exécutable contenant les actions de réservation.

J'ai besoin pour le moment de choisir précisément les outils de communication à chaque étape et de définir comment tout ce petit monde fonctionne ensemble... une idée ?

**hegros** · 22/01/2006, 18h23

Envoyé par clubmed01

Un client émet une requête de consultation des places de spectacle. le serveur reçoit la requête, consulte la mémoire partagée (là, je pige pas comment on fait). il renvoit la réponse au client.

La question est comment on va émettre et qu'est-ce qu'on doit emettre au serveur ?

Qu'est-ce qu'on emet ? Une date ? Une seance ? Un cinéma ? Un ensemble de tout cela ?

Comment ? Socket ? File de message ? Pipe ?

Pour la mémoire partagéé elle doit surement contenir des réservations.
Ce qui serait une structure de cette forme :
Struct reservation { date, seance, cinema,...}

En programmation ce n'est pas bien compliqué ( voir shmget, shmat...)

Le serveur peut recevoir plusieurs requêtes simultanées en consultation.
Lorsque le client émet une requête de réservation, il consulte la mémoire partagée et bloque celle-ci pour ne pas qu'un autre processus y accède en même temps (une seule écriture à la fois). il faut donc gérer ici la synvhronisation (sémaphores ?).

A priori oui une sémaphore.

je pense qu'il faut utiliser entre client et serveur les sockets en local (je rappelle que tout se passe sur la même machine)

On pourrait utiliser une file de message.

- les processus fils du processus serveur Réservation recouvrent le code hérité du père par une code exécutable contenant les actions de réservation.

Le recouvrement c'est typiquement le chargement d'un code executable dans le processus. ( voir exec )

**clubmed01** · 22/01/2006, 19h03

j'ai du mal à savoir comment commencer...

Entre client et serveur, Files de messages ou socket ?

Ca revient au même ?

**hegros** · 22/01/2006, 20h17

Découpe ton application en plusieurs parties claires :

1- Partie reservation
2- Partie consultation.
...
Comment se passe une reservation ? ( Avec des cas d'utilisation ).
Comment se passe une consultation ? ( Avec des cas d'utilisation ).

**clubmed01** · 22/01/2006, 20h34

PARTIE CONSULTATION :

le client envoit une requête pour savoir si le couple (film, date) est dispo.
le serveur lui renvoit le nombre de places disponibles ; s'il n'y a pas de palces diso, message :"pas de places".

PARTIE RÉSERVATION :
le client envoit le triplet (film, date, nb_places) au serveur. Si le nombre de places demandées est inférieur ou égal au nombre de palces disponibles, le nombre de palces est décrémenté, et le serveur renvoit au client un acquitement de réservation. Dans le cas contraire, le serveur renvoit un message d'erreur au client.

QUESTIONS :
En consultation, comme en réservation, le serveur traite-t-il les requêtes les unes après les autres ou simultanément avec des mécanismes de synchronisation ?

**clubmed01** · 22/01/2006, 21h26

Bon, je me suis fait violence; pour répondre à ta question plus précisément, j'ai écrit les 2 requêtes client CONSULATION et RESERVATION (les plus faciles) mais elles comportent certainement des erreurs :

********** CLIENT-CONSULTATION **********

Le processus client envoie le nom du film et la date, et reçoit en retour le nombre de places disponibles.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/****************************************************************************************/
/* Processus client: envoi de la requête de consultation : Nom du film et Date */
/****************************************************************************************/
 
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define CLE 314
 
struct requete {
long letype;
char film(30);
int date;
pid_t mon_pid;
};
 
struct reponse {
long letype;
int reponse;
};
 
main()
{
int msqid, l, film, date;
struct requete la_requete;
struct reponse la_reponse;
 
/* récupération du msqid */
if((msqid=msgget((key_t)CLE,0))<0)
{
perror("msgget");
exit(1);
}
 
/* préparation de la requête et envoi */
 
printf ("Nom du film, date :");
scanf ("%d %d", &film, &date);
la_requete.letype = 1;
la_requete.date = date;
la_requete.film = film;
la_requete.mon_pid = getpid();
 
if(msgsnd(msqid,&la_requete,sizeof(struct requete)-4,0)==-1)
{
perror("msgsnd");
exit(2);
}
 
/* réception de la réponse */
if((l=msgrcv(msqid,&la_reponse,sizeof(struct reponse)-4,getpid(),0)==-1))
{
perror("msgrcv");
exit(2);
}
 
printf ("le resultat reçu est: %d", la_reponse.res);
exit(0);
}

********** CLIENT-RÉSERVATION **********
Le processus client envoie le nom du film, la date, et le nombre de places à réserver. Il reçoit en retour un accusé si les places sont dispos, un code d’erreur en cas contraire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
/*********************************************************************************************/
/* 	Processus client: envoi de la requête de réservation:                                    */
/* 	Nom du film, Date et nombre de places à réserver:                                       */
/*********************************************************************************************/
 
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define CLE 17
 
struct requete {
long letype ;
char film(30) ;
int date ;
int nb_places ;
pid_t mon_pid ;
} ;
 
struct reponse {
long letype ;
int reponse ;
} ;
 
main()
{
int msqid, l, film, date ;
struct requete la_requete ;
struct reponse la_reponse ;
 
/* récupération du msqid */
if((msqid=msgget((key_t)CLE,0))<0)
{
perror("msgget") ;
exit(1) ;
}
 
/* préparation de la requête et envoi */
 
printf ("Nom du film, date et nombre de places :");
scanf ("%d %d %d", &film, &date, &nb_places) ;
la_requete.letype = 1 ;
la_requete.date = date ;
la_requete.film = film ;
la_requete.nb_places = nb_places ;
la_requete.mon_pid = getpid();
 
if(msgsnd(msqid,&la_requete,sizeof(struct requete)-4,0)==-1)
{
perror("msgsnd");
exit(2);
}
 
/* réception de la réponse */
if((l=msgrcv(msqid,&la_reponse,sizeof(struct reponse)-4,getpid(),0)==-1))
{
perror("msgrcv");
exit(2);
}
 
printf ("le resultat reçu est: %d", la_reponse.res);
exit(0);
}

**hegros** · 22/01/2006, 21h56

T'as fourni deux fois le meme code

La partie réservation a l'air pas mal ( sur l'idée ) reste à faire le processus qui se charge de lire dans la file de message les demandes puis de consulter dans la mémoire partagé ( avec semaphore ou sans semaphore pour commencer) la disponibilité et ensuite répondre dans la file de message ( type+2 avec le getpid())

Tu vois ce que je veux dire ?

Tu dois avoir un processus qui se charge de lire dans le file de message les demandes de consultations ( et il ne fait que cela). A chaque fois qu'il lit un message il crée un processus et ce dernier se charge de lire la mémoire partagée et de répondre...

**clubmed01** · 22/01/2006, 22h14

je vais essayer demain, car ce soir j'arrive plus à rien. Les choses s'éclaircissent doucement. Merci du coup de pouce ! La deuxième manche demain !!!

**clubmed01** · 23/01/2006, 21h51

Bonsoir,
j'ai saisis en gros ce que tu as écrit. Cependant, j'ai du mal à mettre en ordre tout ce petit monde.
Pour m'y retrouver, j'ai fais la liste des fonctions que réalisent le processus père et le processus fils du serveur :

PÈRE :
- création de la FILE DE MESSAGE
- création de la zone de MÉMOIRE PARTAGÉE

FILS :
- lecture de la FILE DE MESSAGE
- accès à la zone de MÉMOIRE PARTAGÉE
- utilisation d'un SÉMAPHORE dans le cas d'une écriture

est-ce que je suis sur la bonne voie ? Peux-tu compléter ?

**hegros** · 23/01/2006, 22h02

Ca a l'air pas mal. essaie de compléter avec des cas d'utilisation.

Process père Consultation :

-Attente d'une demande ( Lecture de la file de message type=1)
-Une demande arrive.
-Création d'un processus fils et retour à l'attente d'une demande

Processus fils Consultation
-Pose d'un sémaphore sur la mémoire partagée.
-Attachement à la mémoire partagée
-Recherche des informations dans la mémoire partagée
-Dépose du sémaphore
-Détachement de la mémoire partagée
-Réponse dans la file de message ( type=2)

On pourrait penser que le père crée un pipe par lequel il transmet la structure consultation au fils. ( En effet une lecture dans une file de message est destructive, un message lue est un message qui n'existe plus dans la liste, si mes souvenirs sont bons)

Voila en gros pour l'idée. N'hesite surtout pas à changer la façon dont tu vas faire les choses. Il existe surement d'autres solutions utilise celle qui te semble la meilleure.

Bon courage

**clubmed01** · 28/01/2006, 12h02

j'ai du mal à bien comprendre la communication entre le père et le fils.
Le père :
- récupère requete_consultation depuis la MSQ
- ouvre un tube en écriture
- écrit requete_consultation dans le tube
-crée un fils : fork()

* si fils, alors :
- lit le tube (pas d'écriture)
- exécute le programme "consultation"
- récupère resultat_consultation

et là, il écrit dans un deuxième tube que va lire le père, celui-ci envoyant le résultat dans la MSQ ? ou bien c'est le fils lui-même qui écrit dans la MSQ ?

* si père, alors :
et bien ça dépend de la réponse ci-dessus...

Dans les 2 cas, je fais effectuer la consultation dans la mémoire partagée par un programme executable; il effectuera les tâches suivantes :
- Pose d'un sémaphore sur la mémoire partagée.
- Attachement à la mémoire partagée
- Recherche des informations dans la mémoire partagée
- Dépose du sémaphore
- Détachement de la mémoire partagée

Qu'en penses-tu ?

PS : j'utilise un prog exec car dans l'énoncé, il est écrit que le code du fils recouvre celui du père... c'est bon ?

**hegros** · 28/01/2006, 13h41

Dans les 2 cas, je fais effectuer la consultation dans la mémoire partagée par un programme executable; il effectuera les tâches suivantes :
- Pose d'un sémaphore sur la mémoire partagée.
- Attachement à la mémoire partagée
- Recherche des informations dans la mémoire partagée
- Dépose du sémaphore
- Détachement de la mémoire partagée

Qu'en penses-tu ?

PS : j'utilise un prog exec car dans l'énoncé, il est écrit que le code du fils recouvre celui du père... c'est bon ?

Oui c'est bien cela.

Le fils ne recrée pas un second tube il écrit directement le resultat dans la file des message

Bon courage !

**clubmed01** · 28/01/2006, 21h43

OK pour le fils dans le fork. Mais j'ai d'autres questions, j'espère pas trop "débiles":
-Dans le cas "si c'est le père" dans le fork, le père fait quoi ?
- Qui clos le tube ? Le fils ?

Pour l'appel à un executable, c'est bon ?

**hegros** · 28/01/2006, 23h14

Le père ne fait que de lire dans la file de message les demandes de consultation.

Lorsqu'une demande est lue il crée un fils et un tube. Dans le tube il écrit les données. Puis il recommence sa boucle de lecture dans la file.

Le fils clos le tube après avoir lu les données.

**clubmed01** · 29/01/2006, 23h36

Bon, je finalise. Voici la structure des messages échangés :

Consultation des places disponibles :

Requête :

struct requete_cons {
long letype ; /* destinataire du message */
pid_t mon_pid ; /* N° PID de l’expéditeur */
char nom ; /* nom du spectacle */
long date; /* date du spectacle jjmmaaaa */
} ;

Réponse :

struct reponse_cons {
long letype ;
int nb_dispo ; /* nombre de places disponibles */
};

Réservation de nb_places :

Requête :

struct requete_resa {
long letype ; /* destinataire du message */
pid_t mon_pid ; /* N° PID de l’expéditeur */
char nom ; /* nom du spectacle */
long date; /* date du spectacle jjmmaaaa */
int nb_places /* nombre de places à réserver */
} ;

Réponse :

struct reponse_resa {
long letype ;
short etat ; /* résultat de la réservation */
};

je ne suis pas bien sûr de bien déclarer les différentes variables ; qu'en penses-tu GRAND SAGE ?

PS : demain sera un grand moment, car je finaliserai le code des clients et des serveurs

**hegros** · 30/01/2006, 09h34

Bonjour,

char nom ; /* nom du spectacle */

Ici tu déclares une variable de type caractère. je pense que le nom d'un spectable est une chaîne de caractère. Donc se serait plûtot :

char nom[512] ; /* nom du spectacle */

Ensuite pour la réponse de réservation :

Soit d'accord avec un fonctionnement.
Par exemple si on cherche à réserver 10 places mets que y'en a que 8 de disponible alors rendre la reservation invalide. Si le nombre de place demandé <= nombre de place disponible alors valider la reservation.

PS : Je ne suis pas un grand sage

Aide sur un programme Client Serveur

Linux

Discussions similaires

Partager

Partager