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

{
{ PURPOSE:
{   This contains the user interface stp$remove_member_vol_from_set
{
{ DESIGN:
{   This lives in 23d.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc ste$error_condition_codes
*copyc ost$status
*copyc ost$user_identification
?? POP ??
*copyc clp$validate_name
*copyc dmp$change_set_name
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc pmp$get_user_identification
*copyc stp$clear_exclusive_access
*copyc stp$dm_check_if_files_on_vol
*copyc stp$dm_mount_volume
*copyc stp$request_dm_volume_info
*copyc stp$ring2_remove_member
*copyc stp$search_ast_by_set
*copyc stp$set_exclusive_access
*copyc stp$validate_owner
*copyc stp$validate_recorded_vsn
?? OLDTITLE ??
?? NEWTITLE := '  [XDCL] stp$remove_member_vol_from_set ', EJECT ??
*copyc sth$remove_member_vol_from_set

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

    VAR
      ast_entry: stt$active_set_entry,
      ast_index: stt$ast_index,
      converted_master_vol: rmt$recorded_vsn,
      converted_member_vol: rmt$recorded_vsn,
      converted_set_name: stt$set_name,
      members_avt_index: dmt$active_volume_table_index,
      remove_member_status: ost$status;

    remove_member_status.normal := TRUE;
    validate_remove_mem_param (set_name, member_vol, master_vol, converted_set_name, converted_member_vol,
          converted_master_vol, remove_member_status);
    IF remove_member_status.normal THEN
      stp$set_exclusive_access;
      verify_remove_vol_exec (converted_set_name, converted_member_vol, converted_master_vol,
            members_avt_index, ast_entry, ast_index, remove_member_status);
      IF remove_member_status.normal THEN
        stp$ring2_remove_member (converted_set_name, converted_member_vol, converted_master_vol, ast_entry,
              ast_index, remove_member_status);
      IFEND;
      stp$clear_exclusive_access;
    IFEND;

    IF remove_member_status.normal THEN
      {
      { tell dm that the volume no longer belongs to a set.
      {
      dmp$change_set_name (member_vol, osc$null_name, remove_member_status);
    IFEND;

    status := remove_member_status;

  PROCEND stp$remove_member_vol_from_set;
?? OLDTITLE ??
?? NEWTITLE := '  validate_remove_mem_param', EJECT ??
{
{  PURPOSE:
{    This procedure validates the parameters on the remove_member_vol_from_set
{    request.

  PROCEDURE validate_remove_mem_param
    (    set_name: stt$set_name;
         member_vol: rmt$recorded_vsn;
         master_vol: rmt$recorded_vsn;
     VAR cap_set_name: stt$set_name;
     VAR cap_member_volume: rmt$recorded_vsn;
     VAR cap_master_volume: rmt$recorded_vsn;
     VAR parameter_status: ost$status);

    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 (member_vol, cap_member_volume, parameter_status);
      IF parameter_status.normal THEN
        stp$validate_recorded_vsn (master_vol, cap_master_volume, 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_member_vol_desc, member_vol,
              parameter_status);
      IFEND;
    ELSE
      osp$set_status_abnormal (stc$set_management_id, ste$bad_set_name, set_name, parameter_status);
    IFEND;
  PROCEND validate_remove_mem_param;
?? OLDTITLE ??
?? NEWTITLE := '  verify_member_condition ', EJECT ??

{  PURPOSE:
{    This procedure looks at the member volume and determines, if there is
{    anything from indicate that this member can not be removed from the set.
{    Possible error conditions include not finding the member, the requestor
{    not owning the member, and files on the
{    member.

  PROCEDURE verify_member_condition
    (    set_name: stt$set_name;
         member_vol: rmt$recorded_vsn;
     VAR members_avt_index: dmt$active_volume_table_index;
     VAR member_vol_owner: ost$user_identification;
     VAR member_status: ost$status);

    VAR
      files_on_member: boolean,
      job_owner: ost$user_identification,
      job_owner_status: ost$status,
      member_internal_vsn: dmt$internal_vsn,
      member_vol_found: boolean,
      valid_owner: boolean;

    stp$request_dm_volume_info (member_vol, member_internal_vsn, member_vol_owner, members_avt_index,
          member_vol_found);
    IF member_vol_found THEN
      stp$validate_owner (member_vol_owner, valid_owner);
      IF valid_owner THEN
        stp$dm_check_if_files_on_vol (member_vol, files_on_member);
        IF files_on_member THEN
          osp$set_status_abnormal (stc$set_management_id, ste$files_on_vol, member_vol, member_status);
        ELSE
          member_status.normal := TRUE;
        IFEND;
      ELSE
        pmp$get_user_identification (job_owner, job_owner_status);
        osp$set_status_abnormal (stc$set_management_id, ste$job_not_member_owner, job_owner.user,
              member_status);
        osp$append_status_parameter (osc$status_parameter_delimiter, job_owner.family, member_status);
        osp$append_status_parameter (osc$status_parameter_delimiter, member_vol, member_status);
      IFEND;
    ELSE
      osp$set_status_abnormal (stc$set_management_id, ste$member_not_active, member_vol, member_status);
    IFEND;

  PROCEND verify_member_condition;
?? OLDTITLE ??
?? NEWTITLE := '  verify_remove_member ', EJECT ??
{
{  PURPOSE:
{    This procedure does the validation on the remove_member_vol from set
{    request.  This includes calls to verify the member condition and
{    checking the active set table, to verify correct conditions.
{

  PROCEDURE verify_remove_member
    (    set_name: stt$set_name;
         member_vol: rmt$recorded_vsn;
         master_vol: rmt$recorded_vsn;
     VAR members_avt_index: dmt$active_volume_table_index;
     VAR ast_entry: stt$active_set_entry;
     VAR ast_index: stt$ast_index;
     VAR status: ost$status);

    VAR
      job_owner: ost$user_identification,
      job_owner_status: ost$status,
      member_vol_owner: ost$user_identification,
      set_found: boolean;

    verify_member_condition (set_name, member_vol, members_avt_index, member_vol_owner, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    stp$search_ast_by_set (set_name, ast_entry, ast_index, set_found);
    IF NOT set_found THEN
      { impossible condition }
      {If the member is active and found to be in the correct set by the verify member condition routine,
      {there will be an ast entry.
    IFEND;

    IF member_vol = master_vol THEN
      osp$set_status_abnormal (stc$set_management_id, ste$remove_master_volume, member_vol, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.set_name, status);
      RETURN; {----->
    IFEND;

    IF master_vol <> ast_entry.master_vsn THEN
      {
      {The master_volume supplied by the caller differs from that in the AST.
      {
      osp$set_status_abnormal (stc$set_management_id, ste$wrong_master, master_vol, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, set_name, status);
      RETURN; {----->
    IFEND;

    IF NOT ast_entry.master_ever_up THEN
      osp$set_status_abnormal (stc$set_management_id, ste$master_not_active, master_vol, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, set_name, status);
      RETURN; {----->
    IFEND;

    IF ast_entry.set_owner = member_vol_owner THEN
      IF ast_entry.master_volume_activity.volume_activity_status = stc$active THEN
        status.normal := TRUE;
      ELSE
        osp$set_status_abnormal (stc$set_management_id, ste$master_not_active, master_vol, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, set_name, status);
      IFEND;
    ELSE
      pmp$get_user_identification (job_owner, job_owner_status);
      osp$set_status_abnormal (stc$set_management_id, ste$set_not_member_owner, job_owner.user, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, job_owner.family, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, member_vol, status);
    IFEND;

  PROCEND verify_remove_member;
?? OLDTITLE ??
?? NEWTITLE := '  verify_remove_vol_exec ', EJECT ??

{  PURPOSE:
{    This procedure manages the verification on a remove_vol_from_set request.
{    A manager was used so that supervision of setting exclusive access,
{    and mounting of needed volumes could be provided.

  PROCEDURE verify_remove_vol_exec
    (    set_name: stt$set_name;
         member_volume: rmt$recorded_vsn;
         master_volume: rmt$recorded_vsn;
     VAR members_avt_index: dmt$active_volume_table_index;
     VAR ast_entry: stt$active_set_entry;
     VAR ast_index: stt$ast_index;
     VAR status: ost$status);

    VAR
      local_status: ost$status;

    verify_remove_member (set_name, member_volume, master_volume, members_avt_index, ast_entry, ast_index,
          status);
    IF NOT status.normal THEN
      IF status.condition = ste$member_not_active THEN
        {
        { The member needs to be mounted.
        {
        stp$clear_exclusive_access;
        stp$dm_mount_volume (member_volume, local_status);
        stp$set_exclusive_access;
        IF local_status.normal THEN
          verify_remove_member (set_name, member_volume, master_volume, members_avt_index, ast_entry,
                ast_index, status);
        IFEND;
      IFEND;
      IF NOT status.normal THEN
        IF status.condition = ste$master_not_active THEN
          {
          {The master needs to be mounted.
          {
          stp$clear_exclusive_access;
          stp$dm_mount_volume (master_volume, local_status);
          stp$set_exclusive_access;
          IF local_status.normal THEN
            verify_remove_member (set_name, member_volume, master_volume, members_avt_index, ast_entry,
                  ast_index, status);
          IFEND;
        IFEND;
      IFEND;
    IFEND;

  PROCEND verify_remove_vol_exec;
?? OLDTITLE ??
MODEND stm$remove_member;
