Actualizar exe Cliente-Servidor
 

Hola a todos.
Les comento.
Tengo una aplicación donde el ejecutable lo pongo en el servidor y las PCs tienen un acceso directo en su escritorio, al modificar el ejecutable todos pueden ver las actualizaciones, el problema es que también hay laptops donde tienen el ejecutable en su escritorio ya que tienen que viajar y se conectar por internet, el problema con ellos radica en que al hacer actualizaciones no la pueden ver hasta que les mando el nuevo o llegan y lo sustituyen.
¿Existe una manera de crear un ejecutable que llame a otro o que detecte si la versión es más nueva y se actualice solo?
Ya le estuve buscando y creo que estoy perdido.
Si pudieran ayudarme.
Gracias.

Hola jofebas.

Revisa si te puede servir lo comentado en este hilo: Cerrar aplicacion y a la vez executar otra..

Saludos :)

Gracias lo estoy revisando

Justo tengo un proyecto que funciona así y anda bastante bien.

Lo subo a la noche con código fuente y todo para que me ayuden a optimizarlo.

MAXIUM,

^\||/

Nelson.

Hola,

Bien, aquí esta el proyecto y espero ser claro en poder explicar su funcionamiento. Por otra parte, también me gustaría ayuda en depuración, ya que lo hice a la rápida y al ver que funcionaba, así quedo... :p

Bueno, el asunto es que tengo varias estaciones de trabajo con una aplicación que conecta a la base de datos de un servidor. Todo en forma local por LAN. El problema surge cuando hago actualizaciones del sistema y tengo que ir estación por estación haciendo esto. Así que cree esta aplicación que me resuelve el problema.

Lo otro que se me ocurrió, es que fuera "universal". Es decir, sin necesidad de estar compilando en cada nuevo proyecto. Solo coloco el ejecutable, le creo un acceso directo en el escritorio, le cambio el icono y modifico los parámetros del archivo INI que se adjunta y listo.

Bueno, ¿como funciona? Como explique, la aplicación que creen no se ejecuta directamente, sino que primero el actualizador que actúa como Launcher "universal". Entonces al arrancar el Launcher, este toma la versión del ejecutable a actualizar (importante activar la opción de incluir la versión del exe en las opciones del compilador) y la compara con el "nombre" del archivo en el servidor que contiene la actualización.

Ejemplo:
Si mi aplicación se llama ClubDelphi.exe y su versión es 1.0.0.0 Al ejecutar el launcher toma esta versión y la compara con el "nombre" del archivo que esta en el servidor y que se llama "update_to_1.0.0.102.zip" Si esta es mayor, la descarga, la descomprime y ejecuta un script contenido en el zip, el cual se encarga de reemplazar los archivos que especifiquemos o cualquier otra operación adicional. Este script, es del tipo VBS. Finalmente, ejecuta la aplicación y cierra el launcher.

Notas:
- El launcher y su archivo .ini, deben estar en el mismo directorio que contiene el ejecutable de sus aplicaciones.
- El ejecutable de sus aplicaciones, deben contener la versión.
- En el escritorio crean un acceso directo DEL launcher y le cambian el icono y nombre por el de sus aplicaciones o el que estimen conveniente.
- El servidor debe tener una carpeta compartida y con permisos, donde albergara la actualización.
- El archivo que contienen las actualizaciones, debe estar comprimido en zip con el nombre bajo el siguiente ejemplo update_to_1.2.0.357.zip
- El archivo que contienen las actualizaciones, debe contener un archivo scritp bajo el siguiente nombre script.vbs

Formato del archivo INI que se adjunta
Formato del archivo script que se adjunta. Puede agregar más opciones a este si lo desean y bajo sus necesidades
Estructura principal

Código Delphi [-]
Begin
     ShowWindow(GetConsoleWindow, SW_HIDE);

     Directorio := ExtractFilePath(Application.ExeName);

     LauncherINI:= TIniFile.Create(Directorio + 'Launcher.ini');
     Try
        RutaActualizacion:= LauncherINI.ReadString('RUTA'   , 'Actualizacion', '');
        Aplicacion       := LauncherINI.ReadString('VERSION', 'Ejecutable'   , '');
     Finally
        LauncherINI.Free;
     End;

  // Verifica si hay archivos de actualizaciones dispobibles.
     ListaDeArchivos:= ArchivosCarpeta(RutaActualizacion, '*.zip', True, False);
     If ListaDeArchivos.Count > 0 Then
     Begin
       // Lee los nombres de las actualizaciones disponibles y escoje la última (más reciente).
          Actualizacion:= ListaDeArchivos.Strings[ListaDeArchivos.Count -1];

       // Extrae la numeración de la actualización disponible.
          Version:= ChangeFileExt(ExtractFileName(Actualizacion), '');
          Version:= Copy(Version, 11,  Length(Version));

       // Almacena los valores de ambas versiones en vectores.
          VersionActual    := GetExeVersion(Directorio + Aplicacion);
          VersionDisponible:= GetZipVersion(Version);

       // Comprueba si la actualización es reciente.
          Actualizar:= False;
          Indice    := 1;
          Repeat
                If (VersionDisponible[Indice] > VersionActual[Indice]) Then
                Begin
                    Actualizar:= True;
                    Indice    := 5;
                End
                Else If (VersionDisponible[Indice] = VersionActual[Indice]) Then
                    Inc(Indice)
                Else
                    Indice:= 5;
          Until Indice = 5;

          If Actualizar Then
          Begin
               If Not DirectoryExists(Directorio + 'Temp') Then CreateDir(Directorio + 'Temp') ;

               ShellUnzip(Actualizacion, Directorio + 'Temp');

               WinExecAndWait32(DirectorioSistema + '\wscript.exe ' + GetShortName(Directorio + 'Temp\script.vbs'), SW_SHOWNORMAL)
          End;
     End;
     
     FreeAndNil(ListaDeArchivos);

     WinExec(PChar(Directorio + Aplicacion),SW_SHOWNORMAL);
End.

Cualquier consulta, quedo atento :D

^\||/^\||/^\||/

Muchas gracias por el aporte MAXIUM ^\||/

Saludos :)

Muchas gracias.

Lo estoy probando, cualquier cosa comentare.

De nuevo muchas gracias.^\||/^\||/^\||/

Resuelto
 

hola buenos días.
como no soy muy experto aun en cosas de manejo de archivos y el api y cosas así, o resolví de la siguiente manera.

primero: cree una tabla donde subí el ejecutable como blob y ahí puse la versión en otro campo.
segundo: hice otra aplicación que es que actualizaría la primera o la principal.
el procedimiento es el siguiente:

al abrir el programa, en el evento on_create puse la validación de la versión, si la que tiene la aplicación es diferente a la de la base, abre el actualizador con derechos de administrador y se cierra para que se pueda sustituir el ejecutable.
cuando se abre el actualizador, descarga la el exe que esta en la base (que ya había cargado anteriormente con la versión mas actualizada), al descargarla, crea un acceso directo en el escritorio y lo manda abrir, su cierra el actualizador y listo.

puede funcionar tanto dentro de la lan como en internet, ya que los dos sistemas tienen la validación de la conexión para saber a que servidor conectarse.

aunque la parte de la descarga en un ambiente externo es mas lenta, pero funciona.

bueno espero les de una idea si es que alguien la necesita.

no utilice el scrib MAXIMUN ya que no lo comprendo y no se aun como utilizarlo :o, pero gracias a todos.

¿Y si el archivo que se descarga de internet llega corrupto?
Me suena que esto se ha tratado anteriormente...

Yo hice algo parecido y creaba un archivo con un hash md5

se descargaba desde internet el exe y un txt con la versión y el hash
y asi aseguraba también la descarga correcta.

Código Delphi [-]
......
Var
 nombreup,NombreExe : string;
 TS:TStrings;
 Str, md5hash,md5dest :String;
 pathversion:string;
  Begin
      NombreExe:=ExtractFilepath( Application.ExeName )+'svcgk.exe';
      nombreup:=ExtractFilepath( Application.ExeName )+'svcgk.tmp';
      pathversion:=ExtractFilePath(ParamStr(0))+'version.txt';
      // comparar hash y versión
          TS := TStringList.Create();
          // Coger la version
          try
            TS.LoadFromFile(pathversion);
            Str := TS[0];
            md5hash :=UpperCase(TS[1]);
          except
            try
              ShellExecute(form6.Handle, 'open', PAnsiChar(NombreExe){'svcgk.exe'}, nil, nil,
                 SW_SHOWNORMAL) ;
             Application.Terminate;
            except
              // si hay error intenta abrir otra vez
               ShellExecute(form6.Handle, 'open',PAnsiChar(NombreExe){'svcgk.exe'}, nil, nil,
                 SW_SHOWNORMAL) ;
             Application.Terminate;
            end;
          end;
     md5Dest:=UpperCase(CheckSum(nombreup)); // rutina de otra unidad hashes que compueba el md5
     if md5hash=md5dest then
       begin
         EnablePrivilege('SeDebugPrivilege', TRUE); 
         KillTask('svcgk.exe'); //destruye la tarea
         Sleep(10000); // espero estos 10 segundos para que de tiempo de sobra
         md5Dest:=UpperCase(CheckSum(nombreExe));
         if (md5hash<>md5dest) And
            (copyfile (pchar (Nombreup), Pchar (NombreExe),false)) then
                try
                   DELETEFILE(nombreup);
                   DELETEFILE(pathversion);
                except

                end;
      end;

     ShellExecute(form6.Handle, 'open', PAnsiChar(NombreExe){'svcgk.exe'}, nil, nil, SW_SHOWNORMAL) ;
     Application.Terminate;

Esto es una parte de lo que hice hace tiempo y funcionaba (falta la unidad hasshesy alguna parte de código era por mostrar la comprobación de md5.
Creo que saque ideas de aquí pero fue hace mas de 5 años y casi no me acuerdo

Añado unit hashes que no se ni de donde lo saque..

Código Delphi [-]
unit hashes;

interface

uses Windows, SysUtils, Classes;

function CheckSum(Stream: TStream): string; overload;
function CheckSum(Archivo: string): string; overload;
function StrCheckSum(Str: string): string;

implementation

type
  HCRYPTPROV = ULONG;
  PHCRYPTPROV = ^HCRYPTPROV;
  HCRYPTKEY = ULONG;
  PHCRYPTKEY = ^HCRYPTKEY;
  HCRYPTHASH = ULONG;
  PHCRYPTHASH = ^HCRYPTHASH;
  LPAWSTR = PAnsiChar;
  ALG_ID = ULONG;

const
  CRYPT_NEWKEYSET = $00000008; 
  PROV_RSA_FULL = 1;
  ALG_TYPE_ANY = 0;
  ALG_CLASS_HASH = (4 shl 13);
  ALG_SID_MD5 = 3;
  CALG_MD5 = (ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MD5);
  HP_HASHVAL = $0002;

function CryptAcquireContext(phProv: PHCRYPTPROV;
  pszContainer: LPAWSTR;
  pszProvider: LPAWSTR;
  dwProvType: DWORD;
  dwFlags: DWORD): BOOL; stdcall;
  external ADVAPI32 name 'CryptAcquireContextA';

function CryptCreateHash(hProv: HCRYPTPROV;
  Algid: ALG_ID;
  hKey: HCRYPTKEY;
  dwFlags: DWORD;
  phHash: PHCRYPTHASH): BOOL; stdcall;
  external ADVAPI32 name 'CryptCreateHash';

function CryptHashData(hHash: HCRYPTHASH;
  const pbData: PBYTE;
  dwDataLen: DWORD;
  dwFlags: DWORD): BOOL; stdcall;
  external ADVAPI32 name 'CryptHashData';

function CryptGetHashParam(hHash: HCRYPTHASH;
  dwParam: DWORD;
  pbData: PBYTE;
  pdwDataLen: PDWORD;
  dwFlags: DWORD): BOOL; stdcall;
  external ADVAPI32 name 'CryptGetHashParam';

function CryptDestroyHash(hHash: HCRYPTHASH): BOOL; stdcall;
  external ADVAPI32 name 'CryptDestroyHash';

function CryptReleaseContext(hProv: HCRYPTPROV; dwFlags: DWORD): BOOL; stdcall;
  external ADVAPI32 name 'CryptReleaseContext';

function CheckSum(Stream: TStream): string; overload;
var
  hProv: HCRYPTPROV;
  hHash: HCRYPTHASH;
  Buffer: PByte;
  BytesRead: DWORD;
  Data: array[1..16] of Byte;
  DataLen: DWORD;
  Success: BOOL;
  i: integer;
begin
  Result:= EmptyStr;
  Success := CryptAcquireContext(@hProv, nil, nil, PROV_RSA_FULL, 0);
  if (not Success) then
    if GetLastError() = DWORD(NTE_BAD_KEYSET) then
      Success := CryptAcquireContext(@hProv, nil, nil, PROV_RSA_FULL,
        CRYPT_NEWKEYSET);
  if Success then
  begin
    if CryptCreateHash(hProv, CALG_MD5, 0, 0, @hHash) then
    begin
      GetMem(Buffer,10*1024);
      try
        while  TRUE do
        begin
          BytesRead:= Stream.Read(Buffer^, 10*1024);
          if (BytesRead = 0) then
          begin
            DataLen := Sizeof(Data);
            if (CryptGetHashParam(hHash, HP_HASHVAL, @Data, @DataLen, 0)) then
              for i := 1 to 16 do
                Result := Result + LowerCase(IntToHex(Integer(Data[i]), 2));
            break;
          end;
          if (not CryptHashData(hHash, Buffer, BytesRead, 0)) then
            break;
        end;
      finally
        FreeMem(Buffer);
      end;
      CryptDestroyHash(hHash);
    end;
    CryptReleaseContext(hProv, 0);
  end;
end;

function CheckSum(Archivo: string): string; overload;
var
  Stream: TFileStream;
begin
  Result:= EmptyStr;
  if FileExists(Archivo) then
  try
    Stream:= TFileStream.Create(Archivo,fmOpenRead or fmShareDenyWrite);
    try
      Result:= CheckSum(Stream);
    finally
      Stream.Free;
    end;
  except end;
end;

function StrCheckSum(Str: string): string;
var
  Stream: TStringStream;
begin
  Result:= EmptyStr;
  Stream:= TStringStream.Create(Str);
  try
    Result:= CheckSum(Stream);
  finally
    Stream.Free;
  end;
end;

end.

bueno lo que pasa es que el archivo que descargo es un ejecutable que guardo en la base de datos, en una tabla, lo guardo como tipo BOLB
y ese ejecutable lo subo desde el mismo sistema.

lo he probado y hasta ahora me ha funcionado, si pasa algo, se los comento.

lo subo a una tabla de mysql con Zeos este el el código

Código Delphi [-]
  if not (ZQuery.State in [dsedit, dsinsert]) then
  begin
    ZQuery.Edit;
    ZQuery.Append;
    Try
        ZQuerynombre.AsString := Edit1.Text;
        ZQueryfecha.AsDateTime := Date1.Date;
        ZQueryprog.LoadFromFile('Ruta del *.exe');
        ZQuery.Post;
          finally

      end;
      ShowMessage('--- OK ---');
      ZQuery.Close;

y así lo bajo

Código Delphi [-]
  ZQuery.Open;
  ZQuery.First;
  ZQueryPROG.SaveToFile('ruta del archivo');

Precisamente tengo un proyecto para el futuro en mi nuevo curro (a ver cuándo os informo bien, que a más de uno le gustará) en el que necesito precisamente eso. Por desgracia no nos podemos permitir un Delphi (salvo mi vieja copia de Delphi 6, que no sé si funcionará con los nuevos Windows) así que tengo que tirar de Lazarus y Free Pascal. Por desgracia, lo único que encontré para este compilador necesita muchísismas dependencias, y no cierra la aplicación llamante sino que esta queda en suspenso hasta que la aplicación llamada termina.

Ahora mismo ando liado y no puedo comprobarlo, pero sería genial si la solución de MAXIUM también funcionara con Free Pascal, y si también funcionara en Linux, MacOS e iOS ya sería la repanocha.

Deberias probar porque por ejemplo las aplicaciones que hago con delphi 2010 andan sin problema en windows 10; no creo que haya casi problemas

Seguro que funciona, aunque delphi 6 es de hace unos 15 años :eek: