?? RIGHT := 110 ??
?? NEWTITLE := ' NOS/VE File Server: Client', EJECT ??
MODULE dfm$recover_requests_to_server;

{ PURPOSE:
{   The purpose of this module is to recover all requests to the server
{   present on the client mainframe.  This occurs when the server is
{   being recovered.
{
{ NOTES:
{   This procedure will execute as a separate task
{   and the possibility exists that server termination may be started
{   while this task is executing .

?? NEWTITLE := '    Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc dfc$loopback_server_mainframe
*copyc dfc$poll_constants
*copyc dfe$error_condition_codes
*copyc dft$cpu_queue
*copyc dft$entry_type
*copyc ost$status
?? POP ??
*copyc clp$operator_intervention
*copyc clp$scan_parameter_list
*copyc dfi$display
*copyc dfi$log_display
*copyc dfp$crack_mainframe_id
*copyc dfp$execute_get_app_info
*copyc dfp$execute_state_change_task
*copyc dfp$find_mainframe_id
*copyc dfp$flush_image_file
*copyc dfp$free_image_file
*copyc dfp$verify_client_jobs_request
*copyc dfp$verify_system_administrator
*copyc dfv$recovery_task
*copyc dfv$file_server_debug_enabled
*copyc osp$set_status_abnormal
*copyc osv$emergency_intervention
*copyc pmp$long_term_wait
*copyc syp$hang_if_system_jrt_set

?? TITLE := '    [XDCL, #GATE] dfp$recover_requests_to_server', EJECT ??

  PROCEDURE [XDCL, #GATE] dfp$recover_requests_to_server
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ pdt recover_task_pdt (
{   mainframe_name, mn : name pmc$mainframe_id_size = $required
{   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      recover_task_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^recover_task_pdt_names, ^recover_task_pdt_params];

    VAR
      recover_task_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
            clt$parameter_name_descriptor := [['MAINFRAME_NAME', 1], ['MN', 1], ['STATUS', 2]];

    VAR
      recover_task_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
            clt$parameter_descriptor := [

{ MAINFRAME_NAME MN }
      [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$name_value, pmc$mainframe_id_size, pmc$mainframe_id_size]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      display_string: string (80),
      display_length: integer,
      mainframe_id: pmt$binary_mainframe_id,
      mainframe_found: boolean,
      mainframe_name: pmt$mainframe_id,
      p_cpu_queue: ^dft$cpu_queue,
      p_queue_interface_table: dft$p_queue_interface_table,
      p_q_interface_directory_entry: ^dft$q_interface_directory_entry,
      queue_entry_index: dft$queue_entry_index,
      queue_index: dft$queue_index;

    status.normal := TRUE;

    clp$scan_parameter_list (parameter_list, recover_task_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$crack_mainframe_id ('MAINFRAME_NAME', mainframe_name, mainframe_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$verify_system_administrator ('RECOVER_REQUESTS_TO_SERVER', status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    dfp$find_mainframe_id (mainframe_name, {server_to_client } FALSE, mainframe_found,
          p_queue_interface_table, p_cpu_queue, queue_index, p_q_interface_directory_entry);
    IF NOT mainframe_found THEN
      osp$set_status_abnormal (dfc$file_server_id, dfe$mainframe_not_server, mainframe_name, status);
      RETURN;
    IFEND;
    dfv$recovery_task := TRUE;
    #SPOIL (p_cpu_queue^.queue_header.partner_status.server_state);
    IF p_cpu_queue^.queue_header.partner_status.server_state = dfc$recovering THEN
      IF osv$emergency_intervention THEN
        display (' Emergency intervention in Server recovery');
        clp$operator_intervention (status);
      IFEND;
      log_display ($pmt$ascii_logset [pmc$system_log], ' Sending server image ');
      dfp$flush_image_file (mainframe_id, mainframe_name, status);
      IF NOT status.normal THEN
        log_display_status ($pmt$ascii_logset [pmc$system_log], TRUE, status);
        display_status (status);
      IFEND;
      #SPOIL (p_cpu_queue^.queue_header.partner_status.server_state);
      IF p_cpu_queue^.queue_header.partner_status.server_state = dfc$recovering THEN
        dfp$free_image_file (mainframe_id, status);
        STRINGREP (display_string, display_length, ' ', mainframe_name, '  Verify client jobs ');
        display (display_string (1, display_length));
        log_display ($pmt$ascii_logset [pmc$system_log], display_string (1, display_length));
        dfp$verify_client_jobs_request (mainframe_name, status);
        IF NOT status.normal THEN
          display_status (status);
        IFEND;
        dfp$execute_get_app_info (mainframe_name, status);
        IF NOT status.normal THEN
          display_status (status);
        IFEND;
        syp$hang_if_system_jrt_set (dfc$tjr_recover_req_to_server);
        dfp$execute_state_change_task (mainframe_name, {Partner_is_server} TRUE,
              dfc$awaiting_recovery, dfc$recovering, osc$wait, status);
        p_cpu_queue^.queue_header.partner_status.recovery_complete := TRUE;
      ELSE
        STRINGREP (display_string, display_length, ' Server ', mainframe_name,
              '  state change during recovery ');
        display (display_string (1, display_length));
        log_display ($pmt$ascii_logset [pmc$system_log], display_string (1, display_length))
      IFEND;
      STRINGREP (display_string, display_length, ' ', mainframe_name, '  Recovery completed');
      display (display_string (1, display_length));
      log_display ($pmt$ascii_logset [pmc$system_log], display_string (1, display_length))
    ELSE
      STRINGREP (display_string, display_length, ' ', mainframe_name, '  Recovery task terminated');
      display (display_string (1, display_length));
      log_display ($pmt$ascii_logset [pmc$system_log], display_string (1, display_length))
    IFEND;
    dfv$recovery_task := FALSE;
  PROCEND dfp$recover_requests_to_server;

MODEND dfm$recover_requests_to_server;

