Ada Shut Hook

Question

Hay algunas llamadas de 'limpieza' que quiero que se llamen cuando se apaga/mata una aplicación Ada.

Por ejemplo, si yo estaba en java, me gustaría hacer algo como esto para lograr el efecto de tener algo que se llama al apagar el equipo:

Runtime.getRuntime().addShutdownHook(new Thread(){ 
     public void run(){ 
      method(); 
     } 
}); 

¿Hay algo similar en Ada u otra manera de lograr esto?

Answer 1

Puede crear un objeto Controlado (o Limitado_Controlado) para el procedimiento principal, que llama a las cosas necesarias en su método de Finalización.

Tenga en cuenta que no puede acceder a las variables locales del procedimiento principal, por lo tanto, coloque todo lo necesario en el objeto controlado.

ejemplo:

with Ada.Text_IO; 
with Ada.Finalization; 
procedure Main is 
    type Cleaner is new Ada.Finalization.Limited_Controlled with record 
     Some_Interesting_Data : Integer; 
    end record; 
    overriding procedure Finalize (X : in out Cleaner) is 
    begin 
     Ada.Text_IO.Put_Line ("Cleaning..." & Integer'Image (X.Some_Interesting_Data)); 
    end Finalize; 
    The_Cleaner : Cleaner; 
begin 
    Ada.Text_IO.Put_Line ("Main Procedure."); 
    The_Cleaner.Some_Interesting_Data := 42; 
    Ada.Text_IO.Put_Line ("Finished."); 
end Main; 

Answer 2

Puede raise an exception, que puede ser uno o uno defined by the languagedefined in your program. Su exception handler se ejecutará.

También puede usar Ada.Command_Line.Set_Exit_Status para devolver un código al entorno de invocación.

Addendum: También puede manejar interrupts externo, como se muestra here.

Answer 3

Parece que debería haber una manera de hacer esto en Ada puro, pero no pude encontrar uno.

Una idea sería utilizar Interfaces.C y llamar al atexit() con una función de devolución de llamada que realiza la limpieza. No lo he intentado, pero no puedo pensar en ninguna razón por la que no funcionaría.

More info on Ada callbacks from C

Answer 4

Si se trata de un apagado controlado iniciado por el usuario o debido a que el programa se hace simplemente haciendo lo que hace, a continuación, simplemente puede añadir una última llamada a un procedimiento de limpieza.

Si el programa finaliza debido a una señal de interrupción, como un usuario que envía una señal SIGINT o el sistema se apaga, puede capturar esas señales y poner su procedimiento de limpieza en la devolución de llamada registrada.

Escribí un breve ejemplo sobre cómo detectar interrupciones usando Ada. Está disponible en github y como wiki article.

Otra opción es usar el paquete POSIX de Florist desde libre.adacore.com. Tal vez hay algo útil en el paquete de señales posix.

Answer 5

Puesto que un programa principal Ada es tratado como una tarea, puede utilizar el paquete Ada.Task_Termination para gestionar la limpieza posterior a la ejecución. Hay un escrito sobre esto en el Ada 2005 Rationale, y lo que sigue es una demostración rápida que formé y que se basa en el ejemplo.

usted tiene que proporcionar un procedimiento de terminación nivel de la biblioteca protegida, así que aquí tiene un paquete para que:

with Ada.Task_Termination; 
with Ada.Task_Identification; 
with Ada.Exceptions; 

package Main_Program_Finalization is 

    protected Shutdown_Handler is 

     procedure Termination_Finalizer 
     (Cause : in Ada.Task_Termination.Cause_Of_Termination; 
     T  : in Ada.Task_Identification.Task_Id; 
     X  : in Ada.Exceptions.Exception_Occurrence); 
    end Shutdown_Handler; 

end Main_Program_Finalization; 

cuerpo:

with Text_IO; use Text_IO; 

package body Main_Program_Finalization is 

    protected body Shutdown_Handler is 

     procedure Termination_Finalizer 
     (Cause : in Ada.Task_Termination.Cause_Of_Termination; 
     T  : in Ada.Task_Identification.Task_Id; 
     X  : in Ada.Exceptions.Exception_Occurrence) 
     is 
     use Ada.Task_Termination; 
     use Ada.Task_Identification; 
     use Ada.Exceptions; 
     begin 
     New_Line; 
     Put_Line("Shutdown information:"); 
     New_Line; 
     case Cause is 
     when Normal => 
      Put_Line("Normal, boring termination"); 
     when Abnormal => 
      Put_Line("Something nasty happened to task "); 
      Put_Line(Image(T)); 
     when Unhandled_Exception => 
      Put_Line("Unhandled exception occurred in task "); 
      Put_Line(Image(T)); 
      Put_Line(Exception_Information(X)); 
     end case; 
     end Termination_Finalizer; 

    end Shutdown_Handler; 

end Main_Program_Finalization; 

programa principal (que está establecido para una terminación normal según lo fijado , descomente las dos últimas líneas y ejecútelo para ver el efecto de una terminación desencadenada por excepción no controlada):

with Main_Program_Finalization; 
with Ada.Task_Identification; 
with Ada.Task_Termination; 
with Text_IO; use Text_IO; 

procedure task_term is 

    use Ada; 

    Task_ID : Task_Identification.Task_Id 
    := Task_Identification.Current_Task; 

begin 
    Put_Line("Main Task ID: " & Task_Identification.Image(Task_ID)); 

    Put_Line("Setting termination finalizer"); 
    Task_Termination.Set_Specific_Handler 
    (Task_ID, 
     Main_Program_Finalization.Shutdown_Handler.Termination_Finalizer'Access); 
    Put_Line("Go off and do things now..."); 
    delay 1.0; 
    Put_Line("Done with mainline processing, the shutdown handler should now execute"); 

--  Put_Line("Raise an unhandled exception and see what the shutdown handler does"); 
--  raise Constraint_Error; 
end Task_Term; 

Answer 6

Si se permite que el programa se cierre correctamente, puede usar las funciones de idioma estándar como tipos controlados para proporcionar su comportamiento de "apagado".

Si el SO no puede cerrar bien el programa, entonces no existe una forma definida por el idioma para hacerlo en cualquier idioma. Tendrá que usar algún tipo de llamada de sistema operativo para hacerlo.

Tenga en cuenta que el ejemplo que mostró no era una llamada de Java, sino una llamada de JVM. JVM = Java Virtual Machine ... esencialmente el sistema operativo Java. Puede hacer la misma llamada de Ada, suponiendo que su código Ada se ejecuta en la JVM. Si está ejecutando bajo Windows, tendría que hacerlo con llamadas al sistema Win32. Puedes hacer eso desde Ada, pero obviamente las llamadas exactas no están definidas de manera portátil en el idioma.