Discussion :

[Shredder]

Salut,

Là je suis entrain de créer un projet, avec une application client et un serveur.

En fait j'aimerais que le client puisse gérer plusieurs serveurs à la fois, pour l'instant mon application ne marche que pour un serveur, et j'utilise les composants TClientSocket et TServerSocket.

Le but de mon application est simple, le TClientSocket compris à l'intérieur du serveur, va se connecter au client (qui contient le TServerSocket).

Je suis ennuyé, car je ne vois pas du tout comment je pourrais permettre à mon application de gérer plusieurs serveurs à la fois, en fait ce que je voudrais, c'est que quand on clic sur la liste de tous les serveurs en ligne, le client ouvre une fenetre avec les opérations disponibles sur le serveur sélectionné (et si on clic sur deux serveurs, automatiquement on aurait deux fenêtres qui ne seraient en fait que la même form).

Avant d'aller plus loin, je voudrais vous demander quels sont pour vous les meilleurs composants TCP, apparement ceux-ci ne sont pas bien, et Borland aurait dis qu'ils comprenaient des bugs, d'ou le fait qu'on ne les voit plus lors de l'installation de delphi.
J'ai aussi entendu dire que les composants ICS étaient très bien, ainsi que les composants Indy.

Que me conseillez-vous ?

(Peut-être y en a-t-il des mieux, et des plus simples d'utilisation.)

Merci pour vos réponses.

[ShaiLeTroll]

il suffit d'avoir autant d'instance de TClientSocket que de connexion pour chaque TServerSocket que soit l'IP ou le Port que soit différent, j'ai fait des applis avec 5 port serveur ouvert (donc 5 instances), et les clients se connectaient sur un ou plusieurs port et même se connectait sur applications autre que les notres ... (n instances)

Ah, oui, les composants n'était pas posé sur les forms, mais créér à la volée, bien sur ...

J'ai utilisé massivement TClientSocket et TServerSocket, pour te donner une idée, j'avais des automates fonctionnant des semaines entièrement échangeant une trame toutes les 10ms, ce n'était pas bcp de données, mais bcp de petits echanges ...

sinon, les composants TTcpClient et TTcpServeur de delphi qui remplace TClientSocket et TServerSocket de d6, sont fonctionnel, mais un peu plus chiant à utiliser (faut être habitué aux threads et au mode de fonctionnement bloquant, pas non plus la mer à boire )

Sinon, les Indy, je les ai essayé, mais je m'en souviens plus trop, en terme de confort d'utilisation, je n'ai pas décroché de TClientSocket et TServerSocket

les ICS connait de nom, jamais utilisé ...

[Shredder]

Ok merci, personnellement je n'ai jamais rien vu d'aussi simple que les composants TClientSocket et TServerSocket, et je n'ai jamais vu de bug non plus donc si je pouvais éviter d'en prendre d'autres tant mieux.

Un des petits inconvénients que j'ai pu constater, était que lorsque j'envoyais une chaine très longue avec le SendText (ce que j'ai besoin de faire assès fréquement dans mon programme), je suis obligé d'assembler les chaines bout a bout, car si je met quelque chose du genre edit1.text:=socket.receivetext, je n'ai que la fin de ma chaine.

Les échanges que j'aurais entre le client et le serveur seront donc uniquement des chaines de caractères, mais également des fichiers, donc il va falloir que je fasse un code qui permette de transférer et de recevoir plusieurs fichiers à la fois sur plusieurs serveurs, tout en recevant des données, à l'aide des composants TClientSocket, je pense que ça doit pas être impossible.


Sinon tu disais que tu faisais des petits transferts toutes les 10ms, mais quelle fonction utilisais-tu entre SendText, SendBuff et SendStream ?

[ShaiLeTroll]

Effectivement, dans mes programmes, je découpais les buffers, et ce qui restait était mis en stock et concaténer au prochain packet reçu, mais j'avais l'avantage d'avoir un protocol avec des marqueurs de début fin (genre FD et FE, ou ++ et CRLF) des messages, en plus des entêtes fournissant la longueur et checksum des données ... ainsi une trame incomplète était vite detecté et remis dans le prochain buffer ... mais ce phénomène vient du découpage des données en paquet selon les restrictions du réseau ...

j'utilisais SendText pour envoyer des Chaines, parfois des chaines à parser, parfois un simple dump de zones mémoires (structures) donc contenant tout (de #0 à #255)

Sinon, pour l'envoi de fichier, j'utilise SendBuff (je n'aime pas SendStream et ses comportements chiant sur le stream), je faisais un seul Send mais j'ai plusieurs Receive car buffer découpé par les normes TCP/IP et les limitations réseau ...

tient un code très grossier pour envoyer un BITMAP compressé en JPEG ... si tu gère le multi fichier, il faut se prévoir un protocol plus élaboré qui gère des paquets et l'ordre de ceci dans le fichier, dans certains cas critiques sur le web (sur un LAN c'est RARISSIME) tu peux recevoir des paquets dans le désordre ... le FTP n'est pas là par Hazard ...

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
procedure TFrmShowJPEG.BtnSendClick(Sender: TObject);
var
   Index: Integer;
   DummyJPEg: TJPEGImage;
   DummyBitmap: TBitmap;
   DummyStream: TMemoryStream;
begin
   DummyJPEg := TJPEGImage.Create();
   try
      DummyBitmap := TBitmap.Create();
      try
         DummyStream := TMemoryStream.Create();
         try
            DummyBitmap.Assign(ImageWithDate.Picture.Bitmap);
            DummyBitmap.Canvas.TextOut(0, 0, 'Copy');
            // DummyBitmap.SaveToStream(DummyStream);
            DummyJPEg.Assign(DummyBitmap);
            DummyJPEg.SaveToStream(DummyStream);
 
            if DummyStream.Size > 0 then
            begin
               for Index := 0 to ServerSocketJPEG.Socket.ActiveConnections - 1 do
               begin
                  if ServerSocketJPEG.Socket.Connections[Index].Connected then
                     ServerSocketJPEG.Socket.Connections[Index].SendBuf(DummyStream.Memory^, DummyStream.Size);
                     begin
                        lblRead.Caption := 'Envoyé ...';
                     end;
                     Application.ProcessMessages();
               end;
            end else
            begin
               lblRead.Caption := 'Stream Vide ...';
            end;
 
         finally
            DummyStream.Free(); // Voir l'aide de Delphi pour le TCustomWinSocket.SendStream
         end;
      finally
         DummyBitmap.Free();
      end;
   finally
      DummyJPEg.Free();
   end;
end;

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
 
procedure TFrmShowJPEG.ClientSocketJPEGRead(Sender: TObject;
  Socket: TCustomWinSocket);
var
   DummyStream: TMemoryStream;
   DummyJPEg: TJPEGImage;
   Count, TotalCount: Integer;
   Buffer: Pointer;
begin
   ClientSocketJPEG.OnRead := nil; // important à cause du Application.ProcessMessage...
   try
     lblRead.Caption := 'Réception ...'; lblRead.Refresh();
     try
        DummyStream := TMemoryStream.Create();
        try
           Count := 0;
           TotalCount := 0;
 
           repeat
             lblRead.Caption := 'Réception ... ' + IntToStr(Socket.ReceiveLength) + ' / ' + IntToStr(TotalCount) + '                 '; lblRead.Refresh();
             DummyStream.SetSize(TotalCount+Socket.ReceiveLength);
             Count := Socket.ReceiveBuf(Pointer(Integer(DummyStream.Memory)+TotalCount)^, Socket.ReceiveLength);
             Inc(TotalCount, Count);
 
             MemoLog.Lines.Add(lblRead.Caption);
             Application.ProcessMessages(); // Attention, aux events empilés !
           until Count <= 0;
 
           DummyJPEg := TJPEGImage.Create();
           try
              DummyJPEg.LoadFromStream(DummyStream);
              ImageRead.Picture.Bitmap.Assign(DummyJPEg);
 
           finally
              DummyJPEg.Free();
           end;
        finally
           DummyStream.Free();
        end;
 
        lblRead.Caption := 'Terminé !';
     except
        lblRead.Caption := 'Except : ' + Exception(ExceptObject).Message;
     end;
  finally
     ClientSocketJPEG.OnRead := ClientSocketJPEGRead;
  end;
end;

[Shredder]

ok merci pour ton code

malgrès le fait qu'il y aura plusieurs serveurs, je preferais que le programme client qui gère tous les serveurs n'utilise qu'un seul port, donc pour le multi transfert tu me conseillerais plutôt d'utiliser le FTP ?

[ShaiLeTroll]

C'est juste que le FTP est fait pour cela, à part pour le fun (oui c'est important), autant l'utiliser que des refaire son propre protocol de transfert de fichier ... mais j'ignore comment ça se passe pour envoyer plusieurs fichiers à la fois, car j'ai toujours utilisé des composants bloquants (TNMFTP de FastNet de D6), quoi que quand j'y pense, il m'arrivait de lancer ma procédure d'envoi plusieurs fois de suite, et comme c'était en thread, cela devait faire multi fichier, puisque lorsqu'un thread lit le disque, windows passe la main à un autre qui veut de la ressource CPU ... il réparti normalement "intelligemment" les opérations lentes et rapides ...

[VLDG]

(TNMFTP de FastNet de D6)

FastNet est à mon avis plutôt à éviter.
Mieux vaux utiliser Indy ou ICS pour les gratuits

[ShaiLeTroll]

Effectivement en D7, j'utilise TIdFTP mais je ne l'ai pas utilisé en Thread, donc j'ignore comme il réagit dans le cas d'envoi simultané ...

[Paul TOTH]

personnellement je code toujours les socket à la main

ça n'est pas très compliqué d'une part, et il faut savoir que l'API Socket est disponible sur toutes les plateformes, et ça c'est bien, car si tu sais utiliser les sockets sur un système tu sais les utiliser sur tous les systèmes

j'ai notamment travaillé avec les sockets sur :
- Windows (de 9x à XP en passant par 2K)
- Windows CE
- Linux
- IBM OS/2
- IBM OS/400 (sur AS/400)

ceci en C, Pascal et PHP

y'a pas un mois j'ai codé sur AS/400 en programme qui envoie directement à une page PHP (donc en HTTP) une base de données DB2/400 pour intégration dans MySQL, en quelques heures s'était torché

Indy et ICS sont sans doute très bien, mais quand tu travailles avec ce genres de composants tu apprends à utiliser ces composants justement, alors que les sockets sont pas bien loin derrière et pas très compliquées à utiliser

je ne mettrais qu'un bémol à tout cela, c'est quand il est question d'exploiter un protocole existant, HTTP ça va, FTP c'est pas super compliqué, POP3, SMTP, NNTP c'est bon, LDAP devient un peu plus sioux, notamment car il est en mode binaire et non en texte clair comme les autres, mais plus on va loin dans chaque protocole, plus ça complique, SMTP/POP3 c'est pas compliqué en soit, mais ajouter l'uucode ou le format MIME, voir du HTML ça devient plus compliqué et y'a un moment ou c'est pas mal de prendre un composant tout fait

[ShaiLeTroll]

Tu n'as pas écrit un livre pour rien ... , ce n'est pas non plus à la portée de tout le monde, de connaitre les protocoles ... sinon pour le binaire, je pensais que les autres protocoles étaient du binaire (bon SOAP c'est en XML), genre une zone mémoire que l'on envoie et que l'on peut facilement manipuler ... ayant fait pas mal de programmation industriel, j'ai vu passé bcp de protocol machine différent ...

Sinon pour l'AS400, c'est un RPG (un nom dans le genre), j'ai aussi souvent bossé avec des editeurs de solution de gestion d'entrepot genre MOVEX ou IGE

[uriotcea]

Perso, jutilise TidFTP de indy, massivement parallelement en thread, plus de 100 transfert en meme temps. 1.000.000 transfert en tout. J'ai juste remarqué une leger probleme dans la fonction get avec un serveur particulier