[enabler][1252][zos_copy]Opercmd_usage_for_disposition (#1917)

* First iteration

* Debug

* Solutino using iefbr14

* Add fragment

* Fix lint

* Add fragment

* Add debug

* Fix test

* Return value

* Fix required shr

* Remove test cases that accest to TSO command

* Change calls of datasets

* Rechange logic and delete test cases for opercomand

* Update changelogs/fragments/1917-Opercmd_usage_for_disposition.yml

Co-authored-by: Fernando Flores <[email protected]>

* Fix comments

* Change validation as new stderr is out

---------

Co-authored-by: Fernando Flores <[email protected]>

Author: AndreMarcel99

changelogs/fragments/1917-Opercmd_usage_for_disposition.yml

@@ -0,0 +1,3 @@
+minor_changes:
+  - zos_copy - Removes the need to allow READ access to MVS.MCSOPER.ZOAU to execute the module by changing how the module checks if a data set is locked.
+    (https://github.com/ansible-collections/ibm_zos_core/pull/1917).

plugins/module_utils/data_set.py

@@ -1990,6 +1990,25 @@ def _process_listcat_output(self, output):
                 ).replace("-", "")
         return result
 
+    @staticmethod
+    def verify_dataset_disposition(data_set, disposition):
+        """Function to call iefbr14 to verify the dsp of data_set
+
+        Args:
+            data_set {str}: Name of dataset to verify the dsp=shr
+
+        Returns:
+            bool:  If the data_set is in dsp=shr
+        """
+        data_set_disp = f"{data_set},{disposition}"
+        dd = {"dd" : data_set_disp}
+        rc, stdput, stderr = mvs_cmd.iefbr14(dds=dd)
+
+        if rc != 0:
+            return True
+        else:
+            return False
+
 
 class MVSDataSet():
     """

plugins/module_utils/mvs_cmd.py

@@ -249,6 +249,24 @@ def amaterse(cmd="", dds=None, authorized=False):
     return _run_mvs_command("AMATERSE", "", dds, authorized)
 
 
+def iefbr14(dds=None):
+    """IEFBR14 performs no action other than return a completion code of 0;
+    however, "running" this utility invokes other system components that
+    perform useful tasks.
+
+    Parameters
+    ----------
+    dds : dict
+        Any DD statements to pass to MVS command.
+
+    Returns
+    -------
+    tuple(int, str, str)
+        A tuple of return code, stdout and stderr.
+    """
+    return _run_mvs_command("IEFBR14", "", dds, False)
+
+
 def adrdssu(cmd, dds=None, authorized=False):
     """The ADRDSSU program enables you to copy SMS-compressed data without
     having to decompress the data and also provides support for copying
@@ -302,7 +320,10 @@ def _run_mvs_command(pgm, cmd, dd=None, authorized=False, tmphlq=None):
         mvscmd += "auth"
     if tmphlq:
         mvscmd += " -Q={0}".format(tmphlq)
-    mvscmd += " --pgm={0} --{1}=* --{2}=stdin".format(pgm, sysprint, sysin)
+    if pgm == "IEFBR14":
+        mvscmd += " --pgm={0}".format(pgm)
+    else:
+        mvscmd += " --pgm={0} --{1}=* --{2}=stdin".format(pgm, sysprint, sysin)
     if dd:
         for k, v in dd.items():
             mvscmd += " --{0}={1}".format(k, v)

plugins/modules/zos_copy.py

@@ -946,10 +946,9 @@
     from re import match as fullmatch
 
 try:
-    from zoautil_py import datasets, opercmd, gdgs
+    from zoautil_py import datasets, gdgs
 except Exception:
     datasets = ZOAUImportError(traceback.format_exc())
-    opercmd = ZOAUImportError(traceback.format_exc())
     gdgs = ZOAUImportError(traceback.format_exc())
 
 try:
@@ -3158,56 +3157,6 @@ def normalize_line_endings(src, encoding=None):
     return src
 
 
-def data_set_locked(dataset_name):
-    """
-    Checks if a data set is in use and therefore locked (DISP=SHR), which
-    is often caused by a long running task. Returns a boolean value to indicate the data set status.
-
-    Parameters
-    ----------
-    dataset_name (str):
-        The data set name used to check if there is a lock.
-
-    Returns
-    -------
-    bool
-        True if the data set is locked, or False if the data set is not locked.
-
-    Raises
-    ------
-    CopyOperationError
-        When the user does not have Universal Access Authority to
-        ZOAU SAF Profile 'MVS.MCSOPER.ZOAU' and SAF Class OPERCMDS.
-    """
-    # Using operator command "D GRS,RES=(*,{dataset_name})" to detect if a data set
-    # is in use, when a data set is in use it will have "EXC/SHR and SHARE"
-    # in the result with a length greater than 4.
-    result = dict()
-    result["stdout"] = []
-    dataset_name = dataset_name.replace("$", "\\$")
-    command_dgrs = "D GRS,RES=(*,{0})".format(dataset_name)
-
-    try:
-        response = opercmd.execute(command=command_dgrs)
-        stdout = response.stdout_response
-
-        if stdout is not None:
-            for out in stdout.split("\n"):
-                if out:
-                    result["stdout"].append(out)
-        if len(result["stdout"]) <= 4 and "NO REQUESTORS FOR RESOURCE" in stdout:
-            return False
-
-        return True
-    except zoau_exceptions.ZOAUException as copy_exception:
-        raise CopyOperationError(
-            msg="Unable to determine if the dest {0} is in use.".format(dataset_name),
-                rc=copy_exception.response.rc,
-                stdout=copy_exception.response.stdout_response,
-                stderr=copy_exception.response.stderr_response
-        )
-
-
 def run_module(module, arg_def):
     """Initialize module
 
@@ -3548,7 +3497,7 @@ def run_module(module, arg_def):
     # ********************************************************************
     if dest_exists and dest_ds_type != "USS":
         if not force_lock:
-            is_dest_lock = data_set_locked(dataset_name=dest_name)
+            is_dest_lock = data_set.DataSetUtils.verify_dataset_disposition(data_set=data_set.extract_dsname(dest_name), disposition="old")
             if is_dest_lock:
                 module.fail_json(
                     msg="Unable to write to dest '{0}' because a task is accessing the data set.".format(

tests/functional/modules/test_zos_copy_func.py

@@ -13,7 +13,6 @@
 
 from __future__ import absolute_import, division, print_function
 
-from ibm_zos_core.tests.helpers.users import ManagedUserType, ManagedUser
 import pytest
 import os
 import shutil
@@ -2089,113 +2088,6 @@ def test_copy_dest_lock(ansible_zos_module, ds_type, f_lock ):
         hosts.all.zos_data_set(name=data_set_2, state="absent")
 
 
-def test_copy_dest_lock_test_with_no_opercmd_access_pds_without_force_lock(ansible_zos_module, z_python_interpreter):
-    """
-    This tests the module exeception raised 'msg="Unable to determine if the source {0} is in use.".format(dataset_name)'.
-    This this a wrapper for the actual test case `managed_user_copy_dest_lock_test_with_no_opercmd_access`.
-    """
-    managed_user = None
-    managed_user_test_case_name = "managed_user_copy_dest_lock_test_with_no_opercmd_access"
-    try:
-        # Initialize the Managed user API from the pytest fixture.
-        managed_user = ManagedUser.from_fixture(ansible_zos_module, z_python_interpreter)
-
-        # Important: Execute the test case with the managed users execution utility.
-        managed_user.execute_managed_user_test(
-            managed_user_test_case = managed_user_test_case_name,debug = True,
-            verbose = False, managed_user_type=ManagedUserType.ZOAU_LIMITED_ACCESS_OPERCMD)
-
-    finally:
-        # Delete the managed user on the remote host to avoid proliferation of users.
-        managed_user.delete_managed_user()
-
-@pytest.mark.parametrize("ds_type, f_lock",[
-    ( "pds", False),    # Module exception raised msg="Unable to determine if the source {0} is in use.".format(dataset_name)
-    ( "pdse", False),   # Module exception raised msg="Unable to determine if the source {0} is in use.".format(dataset_name)
-    ( "seq", False),    # Module exception raised msg="Unable to determine if the source {0} is in use.".format(dataset_name)
-    ( "seq", True),     # Opercmd is not called so a user with limited UACC will not matter and will succeed
-])
-def managed_user_copy_dest_lock_test_with_no_opercmd_access(ansible_zos_module, ds_type, f_lock ):
-    """
-    When force_lock option is false, it exercises the opercmd call which requires RACF universal access.
-    This negative test will ensure that if the user does not have RACF universal access that the module
-    not halt execution and instead bubble up the ZOAU exception.
-    """
-    hosts = ansible_zos_module
-
-    data_set_1 = get_tmp_ds_name()
-    data_set_2 = get_tmp_ds_name()
-    member_1 = "MEM1"
-
-    if ds_type == "pds" or ds_type == "pdse":
-        src_data_set = data_set_1 + "({0})".format(member_1)
-        dest_data_set = data_set_2 + "({0})".format(member_1)
-    else:
-        src_data_set = data_set_1
-        dest_data_set = data_set_2
-    try:
-        hosts.all.zos_data_set(name=data_set_1, state="present", type=ds_type, replace=True)
-        hosts.all.zos_data_set(name=data_set_2, state="present", type=ds_type, replace=True)
-        if ds_type == "pds" or ds_type == "pdse":
-            hosts.all.zos_data_set(name=src_data_set, state="present", type="member", replace=True)
-            hosts.all.zos_data_set(name=dest_data_set, state="present", type="member", replace=True)
-        # copy text_in source
-        hosts.all.shell(cmd="decho \"{0}\" \"{1}\"".format(DUMMY_DATA, src_data_set))
-        # copy/compile c program and copy jcl to hold data set lock for n seconds in background(&)
-        temp_dir = get_random_file_name(dir=TMP_DIRECTORY)
-        hosts.all.zos_copy(content=c_pgm, dest=f'{temp_dir}/pdse-lock.c', force=True)
-        hosts.all.zos_copy(
-            content=call_c_jcl.format(temp_dir, dest_data_set),
-            dest=f'{temp_dir}/call_c_pgm.jcl',
-            force=True
-        )
-        hosts.all.shell(cmd="xlc -o pdse-lock pdse-lock.c", chdir=f"{temp_dir}/")
-        # submit jcl
-        hosts.all.shell(cmd="submit call_c_pgm.jcl", chdir=f"{temp_dir}/")
-        # pause to ensure c code acquires lock
-        time.sleep(10)
-        results = hosts.all.zos_copy(
-            src = src_data_set,
-            dest = dest_data_set,
-            remote_src = True,
-            force=True,
-            force_lock=f_lock,
-        )
-        for result in results.contacted.values():
-            if f_lock:
-                assert result.get("changed") == True
-                assert result.get("msg") is None
-                # verify that the content is the same
-                verify_copy = hosts.all.shell(
-                    cmd="dcat \"{0}\"".format(dest_data_set),
-                    executable=SHELL_EXECUTABLE,
-                )
-                for vp_result in verify_copy.contacted.values():
-                    verify_copy_2 = hosts.all.shell(
-                        cmd="dcat \"{0}\"".format(src_data_set),
-                        executable=SHELL_EXECUTABLE,
-                    )
-                    for vp_result_2 in verify_copy_2.contacted.values():
-                        assert vp_result_2.get("stdout") == vp_result.get("stdout")
-            elif not f_lock:
-                assert result.get("failed") is True
-                assert result.get("changed") == False
-                assert "Unable to determine if the dest" in result.get("msg")
-                assert "BGYSC0819E Insufficient security authorization for resource MVS.MCSOPER.ZOAU in class OPERCMDS" in result.get("stderr")
-                assert result.get("rc") == 6
-    finally:
-        # extract pid
-        ps_list_res = hosts.all.shell(cmd="ps -e | grep -i 'pdse-lock'")
-        # kill process - release lock - this also seems to end the job
-        pid = list(ps_list_res.contacted.values())[0].get('stdout').strip().split(' ')[0]
-        hosts.all.shell(cmd="kill 9 {0}".format(pid.strip()))
-        # clean up c code/object/executable files, jcl
-        hosts.all.shell(cmd=f'rm -r {temp_dir}')
-        # remove pdse
-        hosts.all.zos_data_set(name=data_set_1, state="absent")
-        hosts.all.zos_data_set(name=data_set_2, state="absent")
-
-
 @pytest.mark.uss
 @pytest.mark.seq
 def test_copy_file_record_length_to_sequential_data_set(ansible_zos_module):

tests/functional/modules/test_zos_job_output_func.py

@@ -77,8 +77,8 @@ def test_zos_job_output_invalid_owner(ansible_zos_module):
     hosts = ansible_zos_module
     results = hosts.all.zos_job_output(owner="INVALID")
     for result in results.contacted.values():
-        assert result.get("changed") is False
-        assert result.get("jobs")[0].get("ret_code").get("msg_txt") is not None
+        assert result.get("failed") is True
+        assert result.get("stderr") is not None
 
 
 def test_zos_job_output_reject(ansible_zos_module):