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

{ PURPOSE:
{   This  module  provides  the  compilation  unit  for  the  user   interface
{   stp$purge_set request.
{
{ DESIGN:
{   This runs in 23d.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc rmt$recorded_vsn
*copyc ste$error_condition_codes
*copyc dmt$active_volume_table_index
*copyc ost$status
?? POP ??
*copyc clp$validate_name
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc pmp$get_user_identification
*copyc stp$clear_exclusive_access
*copyc stp$dm_mount_volume
*copyc stp$request_dm_volume_info
*copyc stp$ring2_purge_set
*copyc stp$search_ast_by_set
*copyc stp$search_jast_for_set
*copyc stp$set_exclusive_access
*copyc stp$validate_owner
*copyc stp$validate_recorded_vsn
?? OLDTITLE ??
?? NEWTITLE := 'P$VALIDATE_PURGE_SET_PARAM ', EJECT ??

  PROCEDURE p$validate_purge_set_param
    (    set_name: stt$set_name;
         master_vol: rmt$recorded_vsn;
     VAR cap_set_name: stt$set_name;
     VAR cap_master_vol: rmt$recorded_vsn;
     VAR parameter_status: ost$status);

{  PURPOSE:
{    This procedure validates the user parameters on the stp$purge_set request.

    VAR
      local_name: ost$name,
      valid_name: boolean;

    clp$validate_name (set_name, local_name, valid_name);
    IF valid_name THEN
      cap_set_name := local_name;
      stp$validate_recorded_vsn (master_vol, cap_master_vol, parameter_status);
      IF NOT parameter_status.normal THEN
        osp$set_status_abnormal (stc$set_management_id, ste$bad_master_vol_desc, master_vol,
              parameter_status);
      IFEND;
    ELSE
      osp$set_status_abnormal (stc$set_management_id, ste$bad_set_name, set_name, parameter_status);
    IFEND;

  PROCEND p$validate_purge_set_param;
?? OLDTITLE ??
?? NEWTITLE := '  p$verify_purge_set ', EJECT ??

  PROCEDURE p$verify_purge_set
    (    set_name: stt$set_name;
         master_vol: rmt$recorded_vsn;
     VAR masters_avt_index: dmt$active_volume_table_index;
     VAR ast_index: stt$ast_index;
     VAR ast_entry: stt$active_set_entry;
     VAR purge_set_status: ost$status);

{  PURPOSE:
{   The purpose of this routine is to verify that a purge set is indeed
{ legal to do.  This includes validation of the user making the request,
{ and a check on the condition of the set.

    VAR
      internal_vsn: dmt$internal_vsn,
      jast_entry: stt$job_active_set_entry,
      job_owner: ost$user_identification,
      job_owner_status: ost$status,
      master_vol_active: boolean,
      master_vol_owner: ost$user_identification,
      set_found_in_ast: boolean,
      set_found_in_jast: boolean,
      valid_owner: boolean;

    purge_set_status.normal := TRUE;
    stp$search_ast_by_set (set_name, ast_entry, ast_index, set_found_in_ast);
    {
    { Is the set active?
    IF set_found_in_ast THEN
      IF ast_entry.master_ever_up THEN
        stp$validate_owner (ast_entry.set_owner, valid_owner);
        IF valid_owner THEN
          {are there jobs on the set yet}
          stp$search_jast_for_set (set_name, jast_entry, set_found_in_jast);
          IF ((ast_entry.number_of_jobs_using_set > 0) AND NOT set_found_in_jast) OR
                ((ast_entry.number_of_jobs_using_set > 1) AND set_found_in_jast) THEN
{           Only the purge set requestor may be using the set.
            osp$set_status_abnormal (stc$set_management_id, ste$jobs_on_set, set_name, purge_set_status);
            RETURN; {----->
          IFEND;
        ELSE
          pmp$get_user_identification (job_owner, job_owner_status);
          osp$set_status_abnormal (stc$set_management_id, ste$set_not_job_owner, job_owner.user,
                purge_set_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, job_owner.family, purge_set_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, set_name, purge_set_status);
          RETURN; {----->
        IFEND;
      IFEND;
{
{     Do we have the correct master.
      IF ast_entry.master_vsn <> master_vol THEN
        osp$set_status_abnormal (stc$set_management_id, ste$wrong_master, master_vol, purge_set_status);
        osp$append_status_parameter (osc$status_parameter_delimiter, set_name, purge_set_status);
        RETURN; {----->
      IFEND;
{
{     Is the master volume active.
      IF ast_entry.master_ever_up THEN
        IF ast_entry.master_volume_activity.volume_activity_status = stc$active THEN
          masters_avt_index := ast_entry.master_volume_activity.avt_index;
        ELSE
          osp$set_status_abnormal (stc$set_management_id, ste$master_not_active, master_vol,
                purge_set_status);
          osp$append_status_parameter (osc$status_parameter_delimiter, set_name, purge_set_status);
        IFEND;
      ELSE
        osp$set_status_abnormal (stc$set_management_id, ste$master_not_active, master_vol, purge_set_status);
        osp$append_status_parameter (osc$status_parameter_delimiter, set_name, purge_set_status);
      IFEND;
    ELSE
{
{     the master is not active.
      stp$request_dm_volume_info (master_vol, internal_vsn, master_vol_owner, masters_avt_index,
            master_vol_active);
      IF master_vol_active THEN
{       This volume must not belong to the requested set.
        osp$set_status_abnormal (stc$set_management_id, ste$wrong_master, master_vol, purge_set_status);
        osp$append_status_parameter (osc$status_parameter_delimiter, set_name, purge_set_status);
      ELSE
        osp$set_status_abnormal (stc$set_management_id, ste$master_not_active, master_vol, purge_set_status);
        osp$append_status_parameter (osc$status_parameter_delimiter, set_name, purge_set_status);
      IFEND;
    IFEND;

    IF purge_set_status.normal AND ast_entry.pf_root_ever_stored THEN
      osp$set_status_abnormal (stc$set_management_id, ste$users_on_set, set_name, purge_set_status);
    IFEND;

  PROCEND p$verify_purge_set;
?? OLDTITLE ??
?? NEWTITLE := '  [XDCL] stp$purge_set ', EJECT ??
*copyc sth$purge_set

  PROCEDURE [XDCL] stp$purge_set
    (    set_name: stt$set_name;
         master_vol: rmt$recorded_vsn;
     VAR status: ost$status);

    VAR
      ast_entry: stt$active_set_entry,
      ast_index: stt$ast_index,
      cap_master_vol: rmt$recorded_vsn,
      cap_set_name: stt$set_name,
      master_avt_index: dmt$active_volume_table_index,
      purge_set_status: ost$status;

    purge_set_status.normal := TRUE;
    p$validate_purge_set_param (set_name, master_vol, cap_set_name, cap_master_vol, purge_set_status);
    IF purge_set_status.normal THEN
      stp$set_exclusive_access;
      p$verify_purge_set (cap_set_name, cap_master_vol, master_avt_index, ast_index, ast_entry,
            purge_set_status);
      IF NOT purge_set_status.normal THEN
        IF purge_set_status.condition = ste$master_not_active THEN
{         attempt to mount the master volume.
          stp$clear_exclusive_access; {avoid deadlock}
          stp$dm_mount_volume (cap_master_vol, status);
          stp$set_exclusive_access;
          IF status.normal THEN
            p$verify_purge_set (cap_set_name, cap_master_vol, master_avt_index, ast_index, ast_entry,
                  purge_set_status);
          IFEND;
        IFEND;
      IFEND;

      IF purge_set_status.normal THEN
        stp$ring2_purge_set (cap_set_name, cap_master_vol, master_avt_index, ast_index, ast_entry,
              purge_set_status);
      IFEND;
      stp$clear_exclusive_access;
    IFEND;
    status := purge_set_status;

  PROCEND stp$purge_set;
?? OLDTITLE ??
MODEND stm$purge_set;
