Frissítések a felhőből: Egy saját Delphi Update Server felépítése FTP szerver alapokon

A modern szoftverfejlesztés egyik neuralgikus pontja a programfrissítések hatékony és zökkenőmentes kézbesítése a felhasználókhoz. Különösen igaz ez a Delphi alapú asztali alkalmazások világában, ahol a telepített verziók manuális kezelése hamar rémálommá válhat, amint a felhasználói bázis növekszik. Gondoljunk csak bele: hibajavítások, új funkciók, biztonsági frissítések – mindezek eljuttatása anélkül, hogy minden egyes kliensgépen manuálisan kellene beavatkozni, létfontosságú a felhasználói elégedettség és a fejlesztői munkafolyamat szempontjából. Ebben a cikkben részletesen bemutatjuk, hogyan építhetünk fel egy megbízható és automatizált Delphi Update Server rendszert FTP szerver alapokon. ☁️

Miért elengedhetetlen egy automatikus frissítési megoldás?

Kezdetben, néhány felhasználó esetén még elmegy, ha e-mailben küldjük a telepítőket, vagy arra kérjük őket, hogy töltsék le a legújabb verziót egy weboldalról. Azonban hamar eljutunk arra a pontra, ahol ez a módszer tarthatatlanná válik. Miért? Íme néhány ok:

• Felhasználói élmény: Senki sem szeret manuálisan telepítgetni. Egy automatikus rendszer kényelmes és modern.
• Hibajavítások gyors terítése: Kritikus hibák esetén percek alatt elérhetővé tehetjük a javítást mindenki számára.
• Új funkciók bevezetése: Gyorsabb innováció, hiszen az új képességek azonnal megjelennek a felhasználóknál.
• Biztonság: A biztonsági rések orvoslása kulcsfontosságú, és ezt csak frissítésekkel lehet garantálni.
• Kevesebb support: A felhasználók gyakran azért keresik meg a fejlesztőket, mert régi verziót használnak, amiben egy már javított hiba jelentkezik.

Egy dedikált frissítéskezelő rendszer tehát nem luxus, hanem a professzionális szoftverfejlesztés alapköve. 🚀

Miért éppen FTP szerver alapokon?

Valószínűleg felmerül a kérdés: a felhő korszakában, amikor S3-as bucketek és dedikált CDN-ek állnak rendelkezésre, miért pont egy FTP szerver? A válasz egyszerűségben, költséghatékonyságban és hozzáférhetőségben rejlik:

• Egyszerűség: Az FTP protokoll rendkívül egyszerű. Fájlok feltöltése és letöltése a legkevésbé bonyolult hálózati műveletek közé tartozik.
• Elérhetőség: Gyakorlatilag minden webhoszting csomag tartalmaz FTP hozzáférést. Nincs szükség speciális, drága szolgáltatásokra.
• Alacsony költség: Egy meglévő tárhely és némi sávszélesség elegendő, nincs szükség külön infrastruktúra bérlésére.
• Kontroll: Teljes mértékben mi irányítjuk a fájlok elhelyezését és hozzáférését.

Természetesen, az FTP-nek vannak korlátai, elsősorban a biztonság terén (titkosítatlan adatforgalom), de erre is van megoldás, amit később tárgyalunk (FTPS). Kis- és közepes projektekhez, ahol a gyors és egyszerű megvalósítás prioritás, az FTP kiváló választás.

A Delphi Update Rendszer Fő komponensei 🔧

Egy hatékony frissítési rendszer két fő részből áll:

1. Kliens-oldali alkalmazás (a mi Delphi programunk): Ez felelős a verzióellenőrzésért, a frissítések letöltéséért és az updater alkalmazás indításáért.
2. Szerver-oldali tároló (az FTP szerver): Itt tároljuk a frissítésre váró fájlokat, valamint egy metaadat fájlt, ami a jelenlegi verziószámot tartalmazza.

A folyamat logikája a következő:

1. Az alkalmazás induláskor (vagy egy gombnyomásra) kapcsolódik az FTP szerverhez.
2. Letölti a szerveren található verzióinformációt (pl. egy version.ini fájlt).
3. Összehasonlítja a szerveren lévő verziót a saját aktuális verziójával.
4. Ha újabb verziót talál, értesíti a felhasználót, és felajánlja a frissítést.
5. Ha a felhasználó elfogadja, az alkalmazás letölti az új végrehajtható fájlt (és esetleg más szükséges fájlokat) egy ideiglenes mappába.
6. Ezt követően elindít egy külön Updater.exe nevű programot, majd bezárja saját magát.
7. Az Updater.exe megvárja, amíg a fő alkalmazás teljesen bezáródik, felülírja a régi fájlokat az újonnan letöltöttekkel, majd újraindítja a fő alkalmazást.

Részletes útmutató: Lépésről lépésre a megvalósításig 💻

1. Előkészületek az FTP szerveren

Első lépésként szükségünk lesz egy működő FTP szerverre. Ez lehet egy dedikált szerver, egy webhoszting szolgáltatás által biztosított tárhely, vagy akár egy helyi FileZilla Server is tesztelés céljából. Hozzunk létre egy külön mappát a frissítések számára, például /updates/MyApp/.

Ebben a mappában fogjuk tárolni két alapvető fájlt:

• version.ini (vagy update.xml): Ez a fájl tartalmazza a legújabb verziószámot és egyéb metaadatokat (pl. változások listája, letöltendő fájlok nevei, MD5/SHA256 ellenőrzőösszegek).
• MyApp.exe (és egyéb frissítendő fájlok): Maga a frissített alkalmazás és a hozzá tartozó DLL-ek, resource fájlok stb.

Példa egy egyszerű version.ini tartalmára:

[Update]
CurrentVersion=1.0.1.5
ChangeLog="Kisebb hibajavítások, teljesítmény optimalizálás."
Executable=MyApp.exe
MD5Sum=a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6

2. A Delphi kliens-oldali logika – Verzióellenőrzés és letöltés

Ehhez a feladathoz az Indy komponenseket fogjuk használni (TIdFTP). Győződjünk meg róla, hogy telepítve vannak a RAD Studio környezetünkben.

Helyezzünk el egy TIdFTP komponenst a fő űrlapunkra (pl. IdFTP1).

Két privát metódusra lesz szükségünk a verziószám összehasonlításához:

function GetLocalVersion: string;
var
  FileVersionInfo: TFileVersionInfo;
begin
  Result := '0.0.0.0'; // Alapértelmezett érték
  try
    FileVersionInfo := TFileVersionInfo.Create(Application.ExeName);
    try
      Result := FileVersionInfo.ProductVersion;
    finally
      FileVersionInfo.Free;
    end;
  except
    on E: Exception do
      // Hibanapló, ha a verzióinformáció nem olvasható
      OutputDebugString(PChar('Hiba a helyi verzió lekérdezésekor: ' + E.Message));
  end;
end;

function GetRemoteVersion(const AFtpHost, AFtpUser, AFtpPass: string): string;
var
  VersionFile: TStringList;
  IniFile: TMemIniFile;
  CurrentVersion: string;
  LFileName: string;
begin
  Result := '0.0.0.0';
  VersionFile := nil;
  IniFile := nil;

  try
    IdFTP1.Host := AFtpHost;
    IdFTP1.Username := AFtpUser;
    IdFTP1.Password := AFtpPass;
    IdFTP1.Connect;
    try
      LFileName := TPath.GetTempFileName;
      IdFTP1.Get('version.ini', LFileName, True); // Letöltés bináris módban
      
      VersionFile := TStringList.Create;
      VersionFile.LoadFromFile(LFileName);

      IniFile := TMemIniFile.Create;
      IniFile.SetStrings(VersionFile); // Betöltjük a TMemIniFile-ba a tartalmát
      
      CurrentVersion := IniFile.ReadString('Update', 'CurrentVersion', '0.0.0.0');
      Result := CurrentVersion;
    finally
      IdFTP1.Disconnect;
      FreeAndNil(VersionFile);
      FreeAndNil(IniFile);
      TFile.Delete(LFileName); // Töröljük az ideiglenes fájlt
    end;
  except
    on E: Exception do
    begin
      // Hibanapló a hálózati vagy fájlkezelési hibákról
      OutputDebugString(PChar('Hiba a távoli verzió lekérdezésekor: ' + E.Message));
    end;
  end;
end;

Ezeket a metódusokat használva összehasonlíthatjuk a verziókat:

procedure TMainForm.CheckForUpdates;
var
  LocalVersion, RemoteVersion: string;
  LRemoteVersionInfo: TMemIniFile;
begin
  LRemoteVersionInfo := TMemIniFile.Create;
  try
    LocalVersion := GetLocalVersion;
    RemoteVersion := GetRemoteVersion(
      'your.ftp.server.com',
      'ftpuser',
      'ftppass'); // Valódi adatokkal helyettesítendő!

    // A verziószámokat stringként kezeljük, de numerikusan kell összehasonlítani
    // Pl. egy saját verzióösszehasonlító függvénnyel vagy StringReplace '.' és StrToInt.
    // Egyszerűbb, ha StringGrid vagy TStringList segítségével darabokra bontjuk a verziószámot.
    if CompareVersionStrings(RemoteVersion, LocalVersion) > 0 then
    begin
      // Letöltjük az összes verzióinfót, hogy kiírjuk a felhasználónak a változásokat
      // Ehhez újra le kell tölteni a version.ini-t, de ezúttal a teljes tartalmát eltárolva.
      // Ezt a GetRemoteVersion függvényen belül is meg lehetne tenni, ha visszaadná a teljes ini fájlt.
      if MessageDlg(Format('Új verzió érhető el: %s (jelenlegi: %s). Szeretné frissíteni?', [RemoteVersion, LocalVersion]),
                     mtConfirmation, [mbYes, mbNo], 0) = mrYes then
      begin
        // Töltsük le az új alkalmazásfájlt
        DownloadAndUpdateApplication('your.ftp.server.com', 'ftpuser', 'ftppass');
      end;
    end
    else
    begin
      ShowMessage('Az alkalmazás naprakész.');
    end;
  finally
    FreeAndNil(LRemoteVersionInfo);
  end;
end;

// Segédfüggvény a verziószámok összehasonlítására (egyszerűsített példa)
function CompareVersionStrings(const Version1, Version2: string): Integer;
var
  I: Integer;
  V1Parts, V2Parts: TStringList;
  Part1, Part2: Integer;
begin
  V1Parts := TStringList.Create;
  V2Parts := TStringList.Create;
  try
    V1Parts.Delimiter := '.';
    V1Parts.DelimitedText := Version1;
    V2Parts.Delimiter := '.';
    V2Parts.DelimitedText := Version2;

    Result := 0;
    for I := 0 to Max(V1Parts.Count, V2Parts.Count) - 1 do
    begin
      Part1 := 0;
      if I < V1Parts.Count then
        Part1 := StrToIntDef(V1Parts[I], 0);

      Part2 := 0;
      if I < V2Parts.Count then
        Part2 := StrToIntDef(V2Parts[I], 0);

      if Part1 > Part2 then
      begin
        Result := 1; // Version1 nagyobb
        Exit;
      end
      else if Part1 < Part2 then
      begin
        Result := -1; // Version2 nagyobb
        Exit;
      end;
    end;
  finally
    FreeAndNil(V1Parts);
    FreeAndNil(V2Parts);
  end;
end;

A DownloadAndUpdateApplication függvény felelős a fájlok letöltéséért és az Updater.exe elindításáért:

procedure TMainForm.DownloadAndUpdateApplication(const AFtpHost, AFtpUser, AFtpPass: string);
var
  TempFilePath: string;
  UpdaterPath: string;
  LRemoteVersionInfo: TMemIniFile;
  LFileName: string;
  MD5FromIni: string;
  ActualMD5: string;
begin
  LRemoteVersionInfo := TMemIniFile.Create;
  try
    // Letöltjük újra a version.ini-t, hogy kiolvassuk belőle a letöltendő fájl nevét és az MD5-öt
    LFileName := TPath.GetTempFileName;
    IdFTP1.Host := AFtpHost;
    IdFTP1.Username := AFtpUser;
    IdFTP1.Password := AFtpPass;
    IdFTP1.Connect;
    try
      IdFTP1.Get('version.ini', LFileName, True);
      LRemoteVersionInfo.LoadFromFile(LFileName);
      MD5FromIni := LRemoteVersionInfo.ReadString('Update', 'MD5Sum', '');
    finally
      IdFTP1.Disconnect;
      TFile.Delete(LFileName);
    end;

    TempFilePath := TPath.GetTempPath + 'MyApp_new.exe';
    UpdaterPath := TPath.GetTempPath + 'Updater.exe';

    // Fájl letöltése
    IdFTP1.Host := AFtpHost;
    IdFTP1.Username := AFtpUser;
    IdFTP1.Password := AFtpPass;
    IdFTP1.Connect;
    try
      IdFTP1.Get(LRemoteVersionInfo.ReadString('Update', 'Executable', 'MyApp.exe'), TempFilePath, True);
      
      // MD5 ellenőrzés a letöltött fájlon
      ActualMD5 := GetMD5HashFromFile(TempFilePath); // Saját MD5 függvény kell ide
      if (MD5FromIni <> '') and (ActualMD5 <> MD5FromIni) then
      begin
        MessageDlg('Hiba a fájl integritásának ellenőrzésekor! Kérjük, próbálja újra.', mtError, [mbOK], 0);
        Exit; // Kilépünk, ha nem egyezik az MD5
      end;

      // Az Updater.exe letöltése is szükséges lehet, ha nem része a telepítőnek
      // IdFTP1.Get('Updater.exe', UpdaterPath, True); // Feltételezve, hogy van Updater.exe az FTP-n
      // Ha az Updater.exe része az applikációnknak és nem frissül, akkor elég csak átmásolni.
      // Másoljuk át a saját Updater.exe-nket egy ideiglenes helyre, hogy biztosan elinduljon
      TFile.Copy(ExtractFilePath(Application.ExeName) + 'Updater.exe', UpdaterPath, True);
    finally
      IdFTP1.Disconnect;
    end;

    // Updater indítása és saját alkalmazás bezárása
    ShellExecute(0, 'open', PChar(UpdaterPath), PChar(Format('"%s" "%s"', [Application.ExeName, TempFilePath])), nil, SW_SHOWDEFAULT);
    Application.Terminate; // Bezárjuk a fő alkalmazást
  finally
    FreeAndNil(LRemoteVersionInfo);
  end;
end;

// Segédfüggvény MD5 hash generálására fájlból
function GetMD5HashFromFile(const FileName: string): string;
var
  MS: TIdHashMessageDigest5;
  FS: TFileStream;
begin
  Result := '';
  if not TFile.Exists(FileName) then Exit;

  MS := TIdHashMessageDigest5.Create;
  FS := nil;
  try
    FS := TFileStream.Create(FileName, fmOpenRead or fmShareDenyNone);
    Result := MS.HashStreamAsHex(FS);
  finally
    FreeAndNil(FS);
    FreeAndNil(MS);
  end;
end;

3. Az Updater.exe – A Mágia Háttere ✨

Ez egy különálló, nagyon kis méretű Delphi alkalmazás lesz, ami semmi mást nem csinál, csak kicseréli a fájlokat, majd újraindítja a fő programunkat. Ez kritikus, mert egy futó alkalmazás nem tudja felülírni saját magát.

Az Updater.exe-nek parancssori argumentumokat fogunk átadni: az aktuális (régi) alkalmazás útvonalát és az újonnan letöltött (új) alkalmazás útvonalát.

Például: Updater.exe "C:Program FilesMyAppMyApp.exe" "C:TempMyApp_new.exe"

Az Updater.exe kódja egy nagyon egyszerű űrlapon:

procedure TForm1.FormCreate(Sender: TObject);
var
  OldAppPath, NewAppPath: string;
  ProcInfo: TProcessInformation;
  StartInfo: TStartupInfo;
begin
  if ParamCount = 2 then // Két paramétert várunk
  begin
    OldAppPath := ParamStr(1); // A futó alkalmazás teljes útvonala
    NewAppPath := ParamStr(2); // Az új alkalmazás teljes útvonala

    // Megvárjuk, amíg a régi alkalmazás bezárul
    // Ehhez szükségünk van a PID-re, amit a fő alkalmazásnak kellene átadnia,
    // vagy egyszerűen megpróbálhatjuk a fájlt felülírni, amíg sikerül.
    // Egy robusztusabb megoldás a FindWindow vagy a WaitForSingleObject.
    // Egyszerűsített példa: próbáljuk meg felülírni, amíg sikerül.
    repeat
      Sleep(100); // Várakozás
    until not FileExists(OldAppPath) or TryCopyFile(NewAppPath, OldAppPath);
    
    // Ha sikeres a másolás, töröljük az ideiglenes fájlt
    if FileExists(OldAppPath) then
    begin
      TFile.Delete(NewAppPath);
    end;

    // Új alkalmazás indítása
    FillChar(StartInfo, SizeOf(StartInfo), 0);
    StartInfo.cb := SizeOf(StartInfo);
    StartInfo.wShowWindow := SW_SHOWNORMAL;
    StartInfo.dwFlags := STARTF_USESHOWWINDOW;
    if CreateProcess(nil, PChar('"' + OldAppPath + '"'), nil, nil, False, 0, nil, nil, StartInfo, ProcInfo) then
    begin
      // Sikeres indítás
    end
    else
    begin
      // Hiba az indításkor
    end;
  end;
  Application.Terminate; // Bezárjuk magunkat
end;

// Segédfüggvény fájlmásoláshoz, ami kezeli a hibákat és újrapróbálkozik
function TryCopyFile(const Source, Destination: string): Boolean;
var
  Retries: Integer;
begin
  Result := False;
  Retries := 0;
  while (not Result) and (Retries < 10) do // 10 próbálkozás, 100 ms-os időközökkel
  begin
    try
      TFile.Copy(Source, Destination, True);
      Result := True;
    except
      on E: Exception do
      begin
        Sleep(100);
        Inc(Retries);
      end;
    end;
  end;
end;

Fontos megjegyezni, hogy az Updater.exe-nek nem szabadna az alkalmazásunk telepítési mappájában lennie, ha az alkalmazással együtt frissülne. Javasolt, hogy az Updater.exe-t is töltsük le az FTP-ről egy ideiglenes mappába, ha szükséges, vagy biztosítsuk, hogy az Updater.exe kódja stabil és ritkán változik.

Fejlesztési tippek és további megfontolások 💡

• Biztonság (FTPS/SFTP): Bár a cikk FTP alapon mutatja be, erősen ajánlott az FTPS (FTP over TLS/SSL) használata, ha a felhasználónevek és jelszavak, vagy maguk a letöltendő fájlok érzékeny adatokat tartalmaznak. Az Indy komponensek támogatják az FTPS-t (TIdFTP.UseTLS beállítása).
• Integritás ellenőrzés (MD5/SHA256): Ahogy a példakódban is szerepel, mindig érdemes a letöltött fájlok ellenőrzőösszegét (hash) összehasonlítani a szerveren tárolt (version.ini-ben lévő) értékkel. Ez garantálja, hogy a fájl sértetlenül és módosítás nélkül érkezett meg.
• Felhasználói élmény: Egy progress bar (előrehaladási sáv) megjelenítése a letöltés során elengedhetetlen, főleg nagyobb fájlok esetén.
• Több fájl frissítése: Ha az alkalmazásunk több DLL-ből, adatfájlból áll, a version.ini-t ki kell terjeszteni egy listával, amely tartalmazza az összes letöltendő fájl nevét és az ellenőrzőösszegét. Ekkor a letöltési folyamat egy ciklusban végrehajtható.
• Hiba kezelés: A hálózati kapcsolatok ingatagok lehetnek. Robusztus hibakezelésre (újrapróbálkozás, felhasználói értesítés) van szükség minden lépésben.
• Admin jogok: Asztali alkalmazások esetén előfordulhat, hogy a telepítési mappába való íráshoz adminisztrátori jogosultságra van szükség. Ezt kezelni kell, például az Updater.exe-t futtatva admin jogokkal (pl. ShellExecute 'runas' igével).
• Automatizált build folyamatok: A frissítési fájlok FTP szerverre való feltöltését érdemes automatizálni a CI/CD (Continuous Integration/Continuous Deployment) folyamatainkba. Egy egyszerű batch szkript vagy PowerShell szkript is megteszi, ami frissíti a version.ini-t és feltölti a fájlokat.

Személyes vélemény és tapasztalat 💭

Évekkel ezelőtt, amikor először szembesültem azzal a kihívással, hogy egy kisméretű üzleti alkalmazásunkat frissíteni kelljen több tucat ügyfélgépén, a kézi telepítések rengeteg időt és energiát emésztettek fel. Ügyfelenként telefonos egyeztetések, távoli asztali bejelentkezések, majd a telepítés futtatása – elképzelhető, milyen frusztráló volt ez mindkét fél számára. Akkoriban egy hasonló FTP alapú megoldás bevezetése valósággal megváltás volt. Az első implementáció még tele volt kompromisszumokkal és hiányosságokkal, de az alapelgondolás működött. Az ügyfelek imádták, hogy nem kell semmit sem tenniük, csak egy kattintás, és máris a legfrissebb verziót használják. Ez jelentősen csökkentette a support hívások számát, és lehetővé tette, hogy sokkal gyorsabban reagáljunk a felhasználói visszajelzésekre.

"Egy jól működő automatikus szoftverfrissítő rendszer az egyik legjobb befektetés, amit egy fejlesztő tehet. Nem csak időt és pénzt takarít meg, de növeli a felhasználói elégedettséget és erősíti az ügyfél-fejlesztő kapcsolatot."

Persze, ahogy az alkalmazás és a felhasználói bázis nőtt, később áttértünk egy komplexebb, HTTP alapú, JSON formátumot használó, dedikált API-val rendelkező frissítő mechanizmusra, de az FTP alapú rendszer volt az a stabil ugródeszka, ami megmutatta az automatizált verziókezelés erejét és előnyeit. Kisebb és közepes projektekhez, vagy ahol a gyors megvalósítás és az alacsony költség prioritás, még ma is kiválóan megállja a helyét. Fontos, hogy ne féljünk belefogni, mert a kezdeti befektetés sokszorosan megtérül.

Összefoglalás

Egy saját Delphi Update Server felépítése FTP szerver alapokon egy rendkívül praktikus és költséghatékony megoldás arra, hogy Delphi asztali alkalmazásaink mindig naprakészek legyenek a felhasználók számára. Bár az FTP protokollnak vannak korlátai, megfelelő biztonsági intézkedésekkel (FTPS, MD5 ellenőrzés) és robusztus kliens-oldali logikával egy megbízható és felhasználóbarát rendszert hozhatunk létre. Az itt bemutatott lépések és kódrészletek kiindulópontként szolgálnak ahhoz, hogy Ön is megalkothassa saját automatikus szoftverfrissítő platformját, és ezzel jelentősen javíthassa alkalmazásai karbantartását és a felhasználói élményt.