?? NEWTITLE := '  NOS/VE Set Management ' ??
MODULE stm$activate_set;
?? RIGHT := 110 ??

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc clc$standard_file_names
*copyc jmc$job_management_id
*copyc jme$queued_file_conditions
*copyc ofe$error_codes
*copyc ste$error_condition_codes
?? POP ??
*copyc amp$close
*copyc amp$get_next
*copyc avp$configuration_administrator
*copyc avp$initialize_family
*copyc avp$system_operator
*copyc clp$evaluate_parameters
*copyc clp$include_line
*copyc clp$put_job_output
*copyc cmp$lock_set_by_task
*copyc cmp$manage_lcu_lock
*copyc cmp$prompt_for_answer
*copyc dfp$rebuild_set_table_clients
*copyc fsp$open_file
*copyc jmp$recover_input_queue
*copyc jmp$system_job
*copyc mmp$create_scratch_segment
*copyc mmp$delete_scratch_segment
*copyc osp$add_family
*copyc osp$generate_message
*copyc osp$generate_output_message
*copyc osp$press_return_to_continue
*copyc osp$set_status_abnormal
*copyc pfp$find_directory_array
*copyc pfp$find_next_info_record
*copyc pfp$get_family_info
*copyc pfp$overhaul_set
*copyc qfp$activate_deferred_family
*copyc stp$change_access_to_set
*copyc stp$get_active_set_list
*copyc stp$remove_inactive_members
*copyc stp$search_ast_by_set
*copyc stp$verify_all_volumes_active
*copyc syp$process_deadstart_status
*copyc osv$lower_to_upper
*copyc stv$system_set_name

  VAR
    osv$verify_missing_volumes: [XREF] boolean;

?? OLDTITLE ??
?? NEWTITLE := 'PROCEDURE stp$activate_set_command', EJECT ??

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

{ PROCEDURE activate_set_pdt (
{   set_name, sn: name = $required
{   validate_set, vs: boolean = TRUE
{   delete_unreconciled_files, duf: boolean = FALSE
{   defer_input_queue, diq: boolean = FALSE
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 9] of clt$pdt_parameter_name,
      parameters: array [1 .. 5] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
        default_value: string (4),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (5),
      recend,
      type4: record
        header: clt$type_specification_header,
        default_value: string (5),
      recend,
      type5: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [101, 9, 18, 15, 21, 15, 968],
    clc$command, 9, 5, 1, 0, 0, 0, 5, ''], [
    ['DEFER_INPUT_QUEUE              ',clc$nominal_entry, 4],
    ['DELETE_UNRECONCILED_FILES      ',clc$nominal_entry, 3],
    ['DIQ                            ',clc$abbreviation_entry, 4],
    ['DUF                            ',clc$abbreviation_entry, 3],
    ['SET_NAME                       ',clc$nominal_entry, 1],
    ['SN                             ',clc$abbreviation_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 5],
    ['VALIDATE_SET                   ',clc$nominal_entry, 2],
    ['VS                             ',clc$abbreviation_entry, 2]],
    [
{ PARAMETER 1
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [8, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 4],
{ PARAMETER 3
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 5],
{ PARAMETER 4
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 5],
{ PARAMETER 5
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 2
    [[1, 0, clc$boolean_type],
    'TRUE'],
{ PARAMETER 3
    [[1, 0, clc$boolean_type],
    'FALSE'],
{ PARAMETER 4
    [[1, 0, clc$boolean_type],
    'FALSE'],
{ PARAMETER 5
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$set_name = 1,
      p$validate_set = 2,
      p$delete_unreconciled_files = 3,
      p$defer_input_queue = 4,
      p$status = 5;

    VAR
      pvt: array [1 .. 5] of clt$parameter_value;

    VAR
      set_name: stt$set_name,
      set_overhaul_choices: pft$set_overhaul_choices;

    IF NOT (avp$configuration_administrator () OR avp$system_operator ()) THEN
      osp$set_status_abnormal ('OF', ofe$sou_not_active, 'configuration_administration, system_operation',
            status);
      RETURN; {----->
    IFEND;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    set_name := pvt [p$set_name].value^.name_value;
    set_overhaul_choices := $pft$set_overhaul_choices [];

    IF pvt [p$validate_set].value^.boolean_value.value
{ } OR pvt [p$delete_unreconciled_files].value^.boolean_value.value THEN
      set_overhaul_choices := $pft$set_overhaul_choices [pfc$all_catalogs, pfc$validate_files,
            pfc$reorganize_catalogs, pfc$reconcile_fmds, pfc$recover_purged_files];
      IF pvt [p$delete_unreconciled_files].value^.boolean_value.value THEN
        set_overhaul_choices := $pft$set_overhaul_choices [pfc$delete_unreconciled_objects] +
              set_overhaul_choices;
      IFEND;
    IFEND;

    stp$activate_set (set_name, set_overhaul_choices, {activating_during_deadstart=} FALSE,
          pvt [p$defer_input_queue].value^.boolean_value.value, status);

  PROCEND stp$activate_set_command;
?? OLDTITLE ??
?? NEWTITLE := 'stp$activate_set', EJECT ??

  PROCEDURE stp$activate_set
    (    input_set_name: stt$set_name;
         set_overhaul_choices: pft$set_overhaul_choices;
         activating_during_deadstart: boolean;
         defer_input_queue: boolean;
     VAR status: ost$status);

    VAR
      ast_entry: stt$active_set_entry,
      ast_found: boolean,
      ast_index: stt$ast_index,
      continue: boolean,
      local_status: ost$status,
      lock_set: boolean,
      logical_unit: iot$logical_unit,
      members_to_remove: stt$inactive_members_to_remove,
      selection: integer,
      set_name: stt$set_name;

    VAR
      v$missing_volue_answer_table: [READ, oss$job_paged_literal] array [1 .. 3] of
            cmt$answer_prompt_table_entry := [
{   } ['Y', 1, 'YES', 3, 'Deletes the missing volumes from the set', 40],
{   } ['N', 1, 'NO ', 2, 'Does not delete the missing volumes from the set', 48],
{   } ['MANS', 4, 'MANAGE_SET', 10, 'Calls the Manage_Set Utility', 28]];

?? NEWTITLE := 'P$MANAGE_SET', EJECT ??

    PROCEDURE p$manage_set
      (    set_name: stt$set_name;
       VAR status: ost$status);

      VAR
        i: integer,
        str: string (100);

      STRINGREP (str, i, '$LOCAL.OSF$DS_LIBRARY.MANAGE_SET, SET_NAME=', set_name, ', INPUT=COMMAND');
      clp$include_line (str (1, i), TRUE, osc$null_name, status);

    PROCEND p$manage_set;
?? OLDTITLE ??
?? EJECT ??

    status.normal := TRUE;
    lock_set := FALSE;

  /main_program/
    BEGIN
      cmp$manage_lcu_lock (cmc$configuration_administrator, cmc$llo_set_lock, lock_set, status);
      IF NOT status.normal THEN
        EXIT /main_program/; {----->
      IFEND;

      set_name := input_set_name;

      stp$search_ast_by_set (set_name, ast_entry, ast_index, ast_found);
      IF ast_found THEN
        IF ast_entry.access_status = stc$allow_access THEN
          osp$set_status_abnormal (stc$set_management_id, ste$set_already_active, set_name, status);
          EXIT /main_program/; {----->
        IFEND;
      IFEND;

      stp$verify_all_volumes_active (set_name, status);
      IF status.condition = ste$set_not_active THEN
        status.condition := ste$quit_lcu;
      IFEND;
      IF NOT status.normal THEN
        IF status.condition = ste$all_volumes_not_active THEN
          osp$generate_message (status, local_status);
          {Ask operator if activate_set should continue
          IF osv$verify_missing_volumes THEN
            clp$put_job_output (' Do you wish to continue this set activation?', status);
            wait_for_go (continue);
            IF NOT continue THEN
              clp$put_job_output (' Set activation terminated', status);
              EXIT /main_program/; {----->
            ELSE
              cmp$prompt_for_answer (' Do you want to delete the missing volumes from the set?',
                    ' Enter yes, no, MANS or ?:', '--ERROR-- You must enter YES, NO or MANS. Please try ' CAT
                    'again.', v$missing_volue_answer_table, selection);

              CASE selection OF
              = 1 =
                members_to_remove.kind := stc$imtr_remove_all_inactive;
                stp$remove_inactive_members (members_to_remove, set_name, status);
                IF NOT status.normal THEN
                  syp$process_deadstart_status (' ', FALSE, status);
                IFEND;

              = 3 =
                p$manage_set (set_name, status);
                IF NOT status.normal THEN
                  syp$process_deadstart_status (' ', FALSE, status);
                IFEND;
              ELSE
                ; { do not remove volume from set
              CASEND;

            IFEND;
          IFEND;
        ELSE
          EXIT /main_program/; {----->
        IFEND;
      IFEND;

      stp$change_access_to_set (set_name, stc$allow_access, status);
      IF NOT status.normal THEN
        EXIT /main_program/; {----->
      IFEND;

      IF set_overhaul_choices <> $pft$set_overhaul_choices [] THEN
        pfp$overhaul_set (set_name, set_overhaul_choices, status);
        IF NOT status.normal THEN
          osp$generate_message (status, local_status);
        IFEND;
      IFEND;

      stp$build_family_list_for_set (set_name, activating_during_deadstart, defer_input_queue, status);

    END /main_program/;

    IF lock_set THEN
      cmp$manage_lcu_lock (cmc$configuration_administrator, cmc$llo_clear_lock, lock_set, local_status);
      IF NOT local_status.normal THEN
        IF NOT status.normal THEN
          osp$generate_message (status, local_status);
        IFEND;
        status := local_status;
      IFEND;
    IFEND;

  PROCEND stp$activate_set;

?? OLDTITLE ??
?? NEWTITLE := 'stp$build_family_list_for_set', EJECT ??

  PROCEDURE [XDCL] stp$build_family_list_for_set
    (    set_name: stt$set_name;
         activating_during_deadstart: boolean;
         defer_input_queue: boolean;
     VAR status: ost$status);

    VAR
      family_info: amt$segment_pointer,
      i: integer,
      ignore_status: ost$status,
      local_status: ost$status,
      p_family_directory: pft$p_directory_array,
      p_info_record: pft$p_info_record,
      str: string (143),
      strl: integer;

    status.normal := TRUE;
    local_status.normal := TRUE;
    mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_random, family_info, status);
    IF status.normal THEN
      RESET family_info.sequence_pointer;
      pfp$get_family_info (set_name, -$pft$catalog_info_selections [], family_info.sequence_pointer, status);
      IF status.normal THEN
        RESET family_info.sequence_pointer;
        pfp$find_next_info_record (family_info.sequence_pointer, p_info_record, status);
        IF status.normal THEN
          pfp$find_directory_array (p_info_record, p_family_directory, status);
          IF status.normal AND (p_family_directory <> NIL) THEN

          /loop_through_families/
            FOR i := LOWERBOUND (p_family_directory^) TO UPPERBOUND (p_family_directory^) DO
              osp$add_family (p_family_directory^ [i].name, set_name, status);
              IF NOT status.normal THEN
                {The system user of the system set is already added
                IF set_name <> stv$system_set_name THEN
                  STRINGREP (str, strl, ' Family: ', p_family_directory^ [i].name, ' from set: ', set_name);
                  clp$put_job_output (str (1, strl), status);
                  clp$put_job_output ('      duplicates an existing family and cannot be activated', status);
                IFEND;
                status.normal := TRUE;
              IFEND;
              avp$initialize_family (p_family_directory^ [i].name, status);
              IF NOT status.normal THEN
                STRINGREP (str, strl, '  The following error occured while initializing family: ',
                      p_family_directory^ [i].name, ' from set: ', set_name);
                clp$put_job_output (str (1, strl), ignore_status);
                osp$generate_output_message (status, ignore_status);
                status.normal := TRUE;
                osp$press_return_to_continue (ignore_status);
              IFEND;
              dfp$rebuild_set_table_clients (p_family_directory^ [i].name, status);
              IF NOT status.normal THEN
                STRINGREP (str, strl, '  The following error occured while rebuilding set table client info: '
                      , p_family_directory^ [i].name, ' from set: ', set_name);
                clp$put_job_output (str (1, strl), local_status);
                osp$generate_output_message (status, local_status);
                status.normal := TRUE;
              IFEND;
              qfp$activate_deferred_family (p_family_directory^ [i].name);
              IF NOT activating_during_deadstart THEN
                jmp$recover_input_queue (p_family_directory^ [i].name, defer_input_queue, status);
                IF NOT status.normal THEN
                  STRINGREP (str, strl, '  The following error occured while recovering the input queue for ',
                        p_family_directory^ [i].name, ' from set: ', set_name);
                  clp$put_job_output (str (1, strl), local_status);
                  osp$generate_output_message (status, local_status);
                  status.normal := TRUE;
                IFEND;
              IFEND;
            FOREND /loop_through_families/;
          IFEND;
        IFEND;
      IFEND;
      mmp$delete_scratch_segment (family_info, local_status);
    IFEND;
  PROCEND stp$build_family_list_for_set;

?? OLDTITLE ??
?? NEWTITLE := 'wait_for_go', EJECT ??

  PROCEDURE wait_for_go
    (VAR continue: boolean);

    VAR
      ba: amt$file_byte_address,
      fid: amt$file_identifier,
      fp: amt$file_position,
      go: string (20),
      s: string (20),
      status: ost$status,
      tc: amt$transfer_count;

    fsp$open_file (clc$job_command_input, amc$record, NIL, NIL, NIL, NIL, NIL, fid, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    WHILE TRUE DO
      s := 'xx';
      amp$get_next (fid, ^s, #SIZE (s), tc, ba, fp, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      #TRANSLATE (osv$lower_to_upper, s, go);
      IF (go (1) = 'Y') OR (go (1, 3) = 'YES') THEN
        amp$close (fid, status);
        continue := TRUE;
        RETURN; {----->
      ELSEIF (go (1) = 'N') OR (go (1, 2) = 'NO') THEN
        amp$close (fid, status);
        continue := FALSE;
        RETURN; {----->
      ELSE
        clp$put_job_output ('--ERROR--  You must enter yes or no.  Please try again.', status);
      IFEND;
    WHILEND;
  PROCEND wait_for_go;

?? OLDTITLE ??
?? NEWTITLE := 'stp$activate_deadstart_sets', EJECT ??

  PROCEDURE [XDCL] stp$activate_deadstart_sets
    (    set_overhaul_choices: pft$set_overhaul_choices;
     VAR status: ost$status);

    VAR
      continue: boolean,
      current_set_list_size: integer,
      local_status: ost$status,
      number_of_sets: stt$number_of_sets,
      p_list_of_sets: ^stt$set_list,
      set_number: stt$number_of_sets,
      str: string (80),
      strl: integer;

    CONST
      initial_set_list_size = 10;

    status.normal := TRUE;

    number_of_sets := initial_set_list_size;
    REPEAT
      current_set_list_size := number_of_sets;
      PUSH p_list_of_sets: [1 .. current_set_list_size];
      stp$get_active_set_list (p_list_of_sets^, number_of_sets);
    UNTIL number_of_sets <= current_set_list_size;

    FOR set_number := 1 TO number_of_sets DO
      status.normal := TRUE;
      IF p_list_of_sets^ [set_number] <> stv$system_set_name THEN
        STRINGREP (str, strl, ' Activating Set: ', p_list_of_sets^ [set_number]);
        clp$put_job_output (str (1, strl), status);
        stp$activate_set (p_list_of_sets^ [set_number], set_overhaul_choices,
              {activating_during_deadstart=} TRUE, {defer_input_queue} FALSE, status);
      IFEND;

      IF NOT status.normal THEN
        IF status.condition = ste$set_already_active THEN
          status.normal := TRUE;
        ELSE
          osp$generate_message (status, local_status);
          clp$put_job_output (' Set not activated. - Do you wish to continue deadstart?', local_status);
          clp$put_job_output (' Enter YES to continue deadstart or NO to abort deadstart.', local_status);
          wait_for_go (continue);
          status.normal := continue;
          IF NOT continue THEN
            RETURN; {----->
          IFEND;
        IFEND;
      IFEND;
    FOREND;

  PROCEND stp$activate_deadstart_sets;
?? OLDTITLE ??
?? NEWTITLE := 'stp$define_family_set', EJECT ??

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

{ PROCEDURE define_family_set_pdt (
{   family_name, fn: name = $required
{   set_name, sn: name = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 5] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [101, 9, 18, 15, 54, 47, 994],
    clc$command, 5, 3, 1, 0, 0, 0, 3, ''], [
    ['FAMILY_NAME                    ',clc$nominal_entry, 1],
    ['FN                             ',clc$abbreviation_entry, 1],
    ['SET_NAME                       ',clc$nominal_entry, 2],
    ['SN                             ',clc$abbreviation_entry, 2],
    ['STATUS                         ',clc$nominal_entry, 3]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$optional_parameter, 0
  , 0],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 2
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 3
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$family_name = 1,
      p$set_name = 2,
      p$status = 3;

    VAR
      pvt: array [1 .. 3] of clt$parameter_value;

    VAR
      family_name: ost$name,
      set_name: stt$set_name;

    IF NOT jmp$system_job () THEN
      osp$set_status_abnormal (jmc$job_management_id, jme$must_be_system_job, 'stp$define_family_set',
            status);
      RETURN; {----->
    IFEND;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    family_name := pvt [p$family_name].value^.name_value;

    IF (pvt [p$set_name].specified) AND (pvt [p$set_name].value <> NIL) THEN
      set_name := pvt [p$set_name].value^.name_value;
    ELSE
      set_name := stv$system_set_name;
    IFEND;

    osp$add_family (family_name, set_name, status);

  PROCEND stp$define_family_set;
?? OLDTITLE ??
MODEND stm$activate_set;
