Software Design einer Server Anwendung

[Deltachaos]

Hi,

Ich Programmiere im Moment einen Socket Server um auf einer Internetseite Echtzeit Kommunikation zu ermöglichen.

Das Software Design der Serveranwendung habe ich mir so vorgestellt:

Für jeden Client wir ein Thread erzeugt damit, sollte ein Client einen Fehler verursachen er rausgeworfen wird ohne den Server zu crashen und um überhaupt mehrere Clients gleichzeitig zu handlen.
Es gibt 2 Möglichkeiten der Authentifizierung:
1. Normales Login (Für späteren Desktop Client benötigt)
2. Senden der Session Id

In beiden fällen wird die User Id aus einer MySQL Datenbank abgefragt. Außerdem müssen Multi Logins möglich sein.
Jetzt aber das Problem: Möchte ein Nutzer dem anderen eine Nachricht senden dann gibt er die User Id des Empfängers an.
Wie organisiere ich das Intern? Ich muss auf einem möglichst elegantem weg von der UserId zu allen betreffenden Client Threads kommen.
Dabei sollten die Daten so abgelegt werden das sie auch nach einem Disconnect leicht zu entfernen sind und möglichst keine Lücken hinterlassen..

Hat jemand eine Idee?

PS: Idee: http://www.delphipraxis.net/152262-a...ve-arrays.html
PPS: Angehängt ist meine aktuelle Code Basis (Lazarus Projekt)

[rollstuhlfahrer]

Um an den Thread zu kommen schlägst du die Session-ID des Empfängers in deiner User-Tabelle nach. Dort sotte der Empfänger dann auch drin stehen. Deine Threads organisierst du in einer Liste. Beim Connect wird einfach ein Listeneintrag angehängt und beim Disconnect wird der entsprechende Eintrag gelöscht. Jetzt speicherst du in den T*Thread.Data-Feldern die Session-ID. Schreibt ein Nutzer einem anderen eine Nachricht, wird also zuerst die Session-ID nachgeschlagen und dann der Thread ermittelt und dem User die Nachricht geschickt.

Soll das ganze per HTTP laufen, wo die Verbindungen nicht länger als 200ms sind, würde ich dir etwas AJAX empfehlen. Der Browser baut eine Verbindung auf. Du hällst diese dann rund 6 Sekunden und solange in der Zeit keine Nachricht für den Benutzer da ist, wird die Verbindung dann serverseitig mit einem bestimmten Signal unterbrochen. Der Browser erkennt das Signal und macht sofort nen Reconnect. Falls eine Nachricht eingetroffen ist, schickst du dem Browser die Nachricht und trennst dann serverseitig die Verbindung. Der Browser baut diese dann sofort wieder auf, nachdem er die Nachricht angezeigt hat. Übrigend das Browsergame Sternenpackt funktioniert nach diesem Prinzip (wenn man die AJAX-Variante findet).

Bernhard

[Deltachaos]

Ok das Problem ist jedoch: Die Session Id gibt es nur wenn der Benutzer über die Seite Connectet.
Ich muss eine Brücke bauen.

Ich muss interne Session Id's vergeben.
und ich muss unter er User Id alle Clients Speichern die Verbunden sind.

das heißt ich könnte es so machen:

Delphi-Quellcode:

var
  Clients: Array of Array of TMainClient;

{ Versuchen die Clients dann so abzuspeichern }

Clients[USERID][1]..
Clients[USERID][2]..
Clients[USERID][3]..

Ist es aber nicht viel Overhad wen z.b. User mit der Id 1 und 10000 verbunden sind?

Delphi-Quellcode:

setLength(Clients, 10000); 
setLength(Clients[10000], 1);
setLength(Clients[1], 1);

Dan sind die dazwischen ja nil.
Oder ist das egal?
Wie Lang kann so ein Array den werden?

Oder gibt es eine Möglichkeit das noch anders zu machen.

PS: Ich nutze dafür kein AJAX. Es wird eine Brige der Flash Sockets auf Javascript verwendet. Darüber simuliere ich sollten HTML5 WebSockets nicht verfügbar sein das WebSockets Protokoll. Wen WebSockets verfügbar sind nutze ich die nativen WebSockets

PPS: Was ich gerade vergesse. Ich kenne vor connect die UserId noch nicht.

Ist es möglich den Thread von mir aus erst mal in einem Themp Array zu speichern und dann zu verschieben?

[LH_Freak]

Hey,
also ich schreib mir für sowas immer eine eigene Klasse mit einer Liste drin.
Also

Delphi-Quellcode:

type
  TClientList = class
  private
    fList: TList;

    function SidToIndex(sid: integer): integer; // gibt den Index des Clients mit der Sid zurück
    
    function getClient(sid: integer): TMainClient;
    procedure setClient(sid: integer; value: TMainClient);
  public
    constructor Create; overload; // Hier muss fList erstellt werden
    destructor Destroy; override; // fList.Free!

    function SidOfClient(aClient: TMainClient): integer; // gibt die Sid eines Clients zurück
    // ...

    property Client[sid: integer]: TMainClient read getClient write setClient; default;
  end;

Ich habe jetzt Prozeduren fürs Hinzufügen von Clients weggelassen, das sollte eigentlich kein Problem sein. Entweder einfach den Client übergeben und er fügt ihn in der Liste ein, oder dass man einzelne Parameter übergibt und er erstellt daraus einen TMainClient und fügt ihn in die Liste ein.
Man kann natürlich auch beides machen
Die anderen Funktionen kannst du so implementieren, funktioniert bei mir immer ganz gut so:

Delphi-Quellcode:

function TClientList.SidToIndex(sid: integer): integer;
begin
  for result := 0 to fList.Count-1 do
    if TMainClient(fList[result]).Sid = sid then exit;
  result := -1;
end;

function TClientList.SidOfClient(aClient: TMainClient): integer;
var aSid: integer;
begin
  aSid := SidToIndex(aClient.sid);
  if aSid = -1 then 
    result := -1
  else
    result := Client[aSid].sid;
end;

function getClient(sid: integer): TMainClient;
var id: integer;
begin
  id := SidToIndex(sid);
  if id = -1 then exit;
  
  result := TMainClient(fList[id]);
end;

procedure setClient(sid: integer; value: TMainClient);
var id: integer;
begin
  id := SidToIndex(sid);
  if id = -1 then exit;
  
  fList[id] := value;
end;

Jetzt hast du das Problem mit dem Overhead nicht mehr, und du kannst z.B. auch einbauen, dass für den Fall, dass ein Client die Verbindung trennt, der Eintrag dazu automatisch gelöscht wird usw. (so mach ich das atm beim Versuch einen XMPP Server zu basteln).
Durch so eine Klasse bist du viel flexibler als über ein dynamisches Array.

Gruß
LH_Freak

[Deltachaos]

Thx das sieht wirtlich interessant aus?

Wie ist das dann mit dem Freigeben?

Delphi-Quellcode:

TClientList.Clients[id].Free;
TClientList.Clients[id] := nil;

oder was?

Und wäre es nicht auch besser eine TObjectList zu nutzen?