?? RIGHT := 110 ??
?? NEWTITLE := 'INSTALL_SOFTWARE Utility: RAP$EXECUTE_INSTALLER_PROCS Interface.' ??
MODULE ram$execute_installer_procs;

{ PURPOSE:
{   This module contains the interface and procedures which perform the
{   execute installer procedures step of the installation process.
{
{ DESIGN:
{   This steps follows the same general design as the other major
{   installation steps.  This step will use the task list to determine if
{   any subproducts have an installer procedure to execute.  If one is
{   found, it will invoke the EXECUTE_INSTALLER_PROCEDURE (hidden)
{   subcommand of INSTALL_SOFTWARE.  The installer procedure will be
{   executed while inside the EXECUTE_INSTALLER_PROCEDURE subutility.
{
{ NOTES:
{

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc rac$installation_cycles
*copyc rae$install_software_cc
*copyc rat$installation_control_record
?? POP ??
*copyc osp$generate_log_message
*copyc osp$set_status_abnormal
*copyc osp$append_status_parameter
*copyc pfp$convert_fs_path_to_pf_path
*copyc pfp$convert_string_to_fs_path
*copyc rap$clear_installation
*copyc rap$execute_installer_procs_utl
*copyc rap$record_step_status
*copyc rap$record_subproduct_status
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] rap$execute_installer_procs', EJECT ??

{ PURPOSE:
{   This interface performs the 'execute installer procedure' step of the
{   installation process.
{
{ DESIGN:
{   This procedure follows the same design as the other major steps of the
{   installation process.
{
{   For each subproduct in the task list that is assigned to this job and
{   which has not failed, determine if it has an installer procedure.  If it
{   does, pass information about the subproduct and the current installation
{   over to the EXECUTE_INSTALLER_PROCEDURE subutility of INSTALL_SOFTWARE.
{   That subutility will execute the installer procedure and return the
{   status.  The failure of one subproduct will not jeopardize the remaining
{   subproducts, each subproduct will be processed independently.
{
{ NOTES:
{   The SUBPRODUCT_FAILED_PROCESSING boolean has been initialized outside of
{   this interface and should never be re-initialized here.
{

  PROCEDURE [XDCL] rap$execute_installer_procs
    (VAR installation_control_record {input, output} : rat$installation_control_record;
     VAR subproduct_failed_processing: boolean;
     VAR status: ost$status);

    VAR
      ignore_status: ost$status,
      local_status: ost$status,
      processing_record: rat$subp_processing_record,
      subproduct_index: rat$subproduct_count,
      task_status: ost$status;


    status.normal := TRUE;

    IF NOT (rac$execute_installer_proc_step IN installation_control_record.processing_header_p^.step_set) THEN
      RETURN;
    IFEND;

    rap$record_step_status (rac$execute_installer_proc_step, rac$step_started, installation_control_record,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  /main/
    FOR subproduct_index := 1 TO UPPERBOUND (installation_control_record.subproduct_processing_records_p^)
          DO
      processing_record := installation_control_record.subproduct_processing_records_p^ [subproduct_index];

      IF (installation_control_record.job_identifier = processing_record.job_identifier) AND
            (rac$execute_installer_proc_task IN processing_record.task_set) AND
            (processing_record.task_status <> rac$task_failed) THEN

        rap$record_subproduct_status (rac$execute_installer_proc_task, rac$task_started, subproduct_index,
              installation_control_record, ignore_status);

        task_status.normal := TRUE;

        IF processing_record.subproduct_info_pointers.attributes_p^.installer_procedure.
              path_container_index <> 0 THEN
          rap$execute_installer_procs_utl (processing_record, TRUE {subproduct_data_available},
                installation_control_record, task_status);
        IFEND;

        IF task_status.normal THEN
          rap$record_subproduct_status (rac$execute_installer_proc_task, rac$task_completed,
                subproduct_index, installation_control_record, ignore_status);
        ELSE
          osp$generate_log_message ($pmt$ascii_logset [pmc$job_log], task_status, ignore_status);
          rap$record_subproduct_status (rac$execute_installer_proc_task, rac$task_failed, subproduct_index,
                installation_control_record, ignore_status);
          subproduct_failed_processing := TRUE;
        IFEND;

      IFEND;
    FOREND /main/;

    rap$clear_installation (installation_control_record, ignore_status);

    rap$record_step_status (rac$execute_installer_proc_step, rac$step_completed, installation_control_record,
          local_status);
    IF status.normal AND (NOT local_status.normal) THEN
      status := local_status;
    IFEND;

  PROCEND rap$execute_installer_procs;

MODEND ram$execute_installer_procs;
